]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
gdk_bitmap/pixmap_unref -> gdk_drawable_unref
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* 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
2693
2694 #ifndef wxPyUSE_EXPORT
2695 // Helper functions for dealing with SWIG objects and such. These are
2696 // located here so they know about the SWIG types and functions declared
2697 // in the wrapper code.
2698
2699 #include <wx/hashmap.h>
2700 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2701
2702
2703 // Maintains a hashmap of className to swig_type_info pointers. Given the
2704 // name of a class either looks up the type info in the cache, or scans the
2705 // SWIG tables for it.
2706 extern PyObject* wxPyPtrTypeMap;
2707 static
2708 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2709
2710 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2711
2712 if (typeInfoCache == NULL)
2713 typeInfoCache = new wxPyTypeInfoHashMap;
2714
2715 wxString name(className);
2716 swig_type_info* swigType = (*typeInfoCache)[name];
2717
2718 if (! swigType) {
2719 // it wasn't in the cache, so look it up from SWIG
2720 name.Append(wxT(" *"));
2721 swigType = SWIG_TypeQuery(name.mb_str());
2722
2723 // if it still wasn't found, try looking for a mapped name
2724 if (!swigType) {
2725 PyObject* item;
2726 name = className;
2727
2728 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2729 (char*)(const char*)name.mbc_str())) != NULL) {
2730 name = wxString(PyString_AsString(item), *wxConvCurrent);
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733 }
2734 }
2735 if (swigType) {
2736 // and add it to the map if found
2737 (*typeInfoCache)[className] = swigType;
2738 }
2739 }
2740 return swigType;
2741 }
2742
2743
2744 // Check if a class name is a type known to SWIG
2745 bool wxPyCheckSwigType(const wxChar* className) {
2746
2747 swig_type_info* swigType = wxPyFindSwigType(className);
2748 return swigType != NULL;
2749 }
2750
2751
2752 // Given a pointer to a C++ object and a class name, construct a Python proxy
2753 // object for it.
2754 PyObject* wxPyConstructObject(void* ptr,
2755 const wxChar* className,
2756 int setThisOwn) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2760
2761 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2762 }
2763
2764
2765 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2766 // Ensures that the proxy object is of the specified (or derived) type. If
2767 // not able to perform the conversion then a Python exception is set and the
2768 // error should be handled properly in the caller. Returns True on success.
2769 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2770 const wxChar* className) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2774
2775 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2776 }
2777
2778
2779
2780 // Make a SWIGified pointer object suitable for a .this attribute
2781 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2782
2783 PyObject* robj = NULL;
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2787
2788 robj = PySwigObject_New(ptr, swigType, 0);
2789 return robj;
2790 }
2791
2792
2793 // Python's PyInstance_Check does not return True for instances of new-style
2794 // classes. This should get close enough for both new and old classes but I
2795 // should re-evaluate the need for doing instance checks...
2796 bool wxPyInstance_Check(PyObject* obj) {
2797 return PyObject_HasAttrString(obj, "__class__") != 0;
2798 }
2799
2800
2801 // This one checks if the object is an instance of a SWIG proxy class (it has
2802 // a .this attribute, and the .this attribute is a PySwigObject.)
2803 bool wxPySwigInstance_Check(PyObject* obj) {
2804 static PyObject* this_str = NULL;
2805 if (this_str == NULL)
2806 this_str = PyString_FromString("this");
2807
2808 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2809 if (this_attr) {
2810 bool retval = (PySwigObject_Check(this_attr) != 0);
2811 Py_DECREF(this_attr);
2812 return retval;
2813 }
2814
2815 PyErr_Clear();
2816 return false;
2817 }
2818
2819
2820 // Export a C API in a struct. Other modules will be able to load this from
2821 // the wx._core_ module and will then have safe access to these functions,
2822 // even if they are located in another shared library.
2823 static wxPyCoreAPI API = {
2824
2825 wxPyCheckSwigType,
2826 wxPyConstructObject,
2827 wxPyConvertSwigPtr,
2828 wxPyMakeSwigPtr,
2829
2830 wxPyBeginAllowThreads,
2831 wxPyEndAllowThreads,
2832 wxPyBeginBlockThreads,
2833 wxPyEndBlockThreads,
2834
2835 wxPy_ConvertList,
2836
2837 wxString_in_helper,
2838 Py2wxString,
2839 wx2PyString,
2840
2841 byte_LIST_helper,
2842 int_LIST_helper,
2843 long_LIST_helper,
2844 string_LIST_helper,
2845 wxPoint_LIST_helper,
2846 wxBitmap_LIST_helper,
2847 wxString_LIST_helper,
2848 wxAcceleratorEntry_LIST_helper,
2849
2850 wxSize_helper,
2851 wxPoint_helper,
2852 wxRealPoint_helper,
2853 wxRect_helper,
2854 wxColour_helper,
2855 wxPoint2D_helper,
2856
2857 wxPySimple_typecheck,
2858 wxColour_typecheck,
2859
2860 wxPyCBH_setCallbackInfo,
2861 wxPyCBH_findCallback,
2862 wxPyCBH_callCallback,
2863 wxPyCBH_callCallbackObj,
2864 wxPyCBH_delete,
2865
2866 wxPyMake_wxObject,
2867 wxPyMake_wxSizer,
2868 wxPyPtrTypeMap_Add,
2869 wxPy2int_seq_helper,
2870 wxPy4int_seq_helper,
2871 wxArrayString2PyList_helper,
2872 wxArrayInt2PyList_helper,
2873
2874 wxPyClientData_dtor,
2875 wxPyUserData_dtor,
2876 wxPyOORClientData_dtor,
2877
2878 wxPyCBInputStream_create,
2879 wxPyCBInputStream_copy,
2880
2881 wxPyInstance_Check,
2882 wxPySwigInstance_Check,
2883
2884 wxPyCheckForApp
2885
2886 };
2887
2888 #endif
2889
2890
2891 #if !WXWIN_COMPATIBILITY_2_4
2892 #define wxHIDE_READONLY 0
2893 #endif
2894
2895
2896 #define SWIG_From_long PyInt_FromLong
2897
2898
2899 SWIGINTERNINLINE PyObject *
2900 SWIG_From_int (int value)
2901 {
2902 return SWIG_From_long (value);
2903 }
2904
2905 static const wxString wxPyEmptyString(wxEmptyString);
2906 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2907 return self->GetClassInfo()->GetClassName();
2908 }
2909 SWIGINTERN void wxObject_Destroy(wxObject *self){
2910 delete self;
2911 }
2912
2913 #ifndef __WXMAC__
2914 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2915 #endif
2916
2917
2918 #include <limits.h>
2919 #ifndef LLONG_MIN
2920 # define LLONG_MIN LONG_LONG_MIN
2921 #endif
2922 #ifndef LLONG_MAX
2923 # define LLONG_MAX LONG_LONG_MAX
2924 #endif
2925 #ifndef ULLONG_MAX
2926 # define ULLONG_MAX ULONG_LONG_MAX
2927 #endif
2928
2929
2930 SWIGINTERN int
2931 SWIG_AsVal_long (PyObject* obj, long* val)
2932 {
2933 if (PyNumber_Check(obj)) {
2934 if (val) *val = PyInt_AsLong(obj);
2935 return SWIG_OK;
2936 }
2937 return SWIG_TypeError;
2938 }
2939
2940
2941 SWIGINTERN int
2942 SWIG_AsVal_int (PyObject * obj, int *val)
2943 {
2944 long v;
2945 int res = SWIG_AsVal_long (obj, &v);
2946 if (SWIG_IsOK(res)) {
2947 if ((v < INT_MIN || v > INT_MAX)) {
2948 return SWIG_OverflowError;
2949 } else {
2950 if (val) *val = static_cast< int >(v);
2951 }
2952 }
2953 return res;
2954 }
2955
2956 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2958 PyObject* tup = PyTuple_New(2);
2959 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2960 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2961 wxPyEndBlockThreads(blocked);
2962 return tup;
2963 }
2964
2965 SWIGINTERN int
2966 SWIG_AsVal_double (PyObject *obj, double* val)
2967 {
2968 if (PyNumber_Check(obj)) {
2969 if (val) *val = PyFloat_AsDouble(obj);
2970 return SWIG_OK;
2971 }
2972 return SWIG_TypeError;
2973 }
2974
2975
2976 #define SWIG_From_double PyFloat_FromDouble
2977
2978 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
2979 self->x = x;
2980 self->y = y;
2981 }
2982 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
2983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2984 PyObject* tup = PyTuple_New(2);
2985 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
2986 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
2987 wxPyEndBlockThreads(blocked);
2988 return tup;
2989 }
2990 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
2991 self->x = x;
2992 self->y = y;
2993 }
2994 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
2995 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2996 PyObject* tup = PyTuple_New(2);
2997 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2998 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2999 wxPyEndBlockThreads(blocked);
3000 return tup;
3001 }
3002 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3003 self->x = x;
3004 self->y = y;
3005 self->width = width;
3006 self->height = height;
3007 }
3008 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3009 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3010 PyObject* tup = PyTuple_New(4);
3011 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3012 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3013 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3014 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3015 wxPyEndBlockThreads(blocked);
3016 return tup;
3017 }
3018
3019 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3020 wxRegion reg1(*r1);
3021 wxRegion reg2(*r2);
3022 wxRect dest(0,0,0,0);
3023 PyObject* obj;
3024
3025 reg1.Intersect(reg2);
3026 dest = reg1.GetBox();
3027
3028 if (dest != wxRect(0,0,0,0)) {
3029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3030 wxRect* newRect = new wxRect(dest);
3031 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3032 wxPyEndBlockThreads(blocked);
3033 return obj;
3034 }
3035 Py_INCREF(Py_None);
3036 return Py_None;
3037 }
3038
3039 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3040 self->m_x = x;
3041 self->m_y = y;
3042 }
3043 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3045 PyObject* tup = PyTuple_New(2);
3046 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3047 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3048 wxPyEndBlockThreads(blocked);
3049 return tup;
3050 }
3051
3052 #include "wx/wxPython/pyistream.h"
3053
3054 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3055 wxInputStream* wxis = wxPyCBInputStream::create(p);
3056 if (wxis)
3057 return new wxPyInputStream(wxis);
3058 else
3059 return NULL;
3060 }
3061
3062 SWIGINTERN swig_type_info*
3063 SWIG_pchar_descriptor()
3064 {
3065 static int init = 0;
3066 static swig_type_info* info = 0;
3067 if (!init) {
3068 info = SWIG_TypeQuery("_p_char");
3069 init = 1;
3070 }
3071 return info;
3072 }
3073
3074
3075 SWIGINTERNINLINE PyObject *
3076 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3077 {
3078 if (carray) {
3079 if (size > INT_MAX) {
3080 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3081 return pchar_descriptor ?
3082 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3083 } else {
3084 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3085 }
3086 } else {
3087 return SWIG_Py_Void();
3088 }
3089 }
3090
3091
3092 SWIGINTERNINLINE PyObject *
3093 SWIG_From_char (char c)
3094 {
3095 return SWIG_FromCharPtrAndSize(&c,1);
3096 }
3097
3098
3099 SWIGINTERNINLINE PyObject*
3100 SWIG_From_unsigned_SS_long (unsigned long value)
3101 {
3102 return (value > LONG_MAX) ?
3103 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3104 }
3105
3106
3107 SWIGINTERNINLINE PyObject *
3108 SWIG_From_size_t (size_t value)
3109 {
3110 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3111 }
3112
3113
3114 SWIGINTERN int
3115 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3116 {
3117 if (PyString_Check(obj)) {
3118 char *cstr; int len;
3119 PyString_AsStringAndSize(obj, &cstr, &len);
3120 if (cptr) {
3121 if (alloc) {
3122 /*
3123 In python the user should not be able to modify the inner
3124 string representation. To warranty that, if you define
3125 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3126 buffer is always returned.
3127
3128 The default behavior is just to return the pointer value,
3129 so, be careful.
3130 */
3131 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3132 if (*alloc != SWIG_OLDOBJ)
3133 #else
3134 if (*alloc == SWIG_NEWOBJ)
3135 #endif
3136 {
3137 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3138 *alloc = SWIG_NEWOBJ;
3139 }
3140 else {
3141 *cptr = cstr;
3142 *alloc = SWIG_OLDOBJ;
3143 }
3144 } else {
3145 *cptr = PyString_AsString(obj);
3146 }
3147 }
3148 if (psize) *psize = len + 1;
3149 return SWIG_OK;
3150 } else {
3151 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3152 if (pchar_descriptor) {
3153 void* vptr = 0;
3154 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3155 if (cptr) *cptr = (char *) vptr;
3156 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3157 if (alloc) *alloc = SWIG_OLDOBJ;
3158 return SWIG_OK;
3159 }
3160 }
3161 }
3162 return SWIG_TypeError;
3163 }
3164
3165
3166 SWIGINTERN int
3167 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3168 {
3169 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3170 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3171 if (SWIG_IsOK(res)) {
3172 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3173 if (csize <= size) {
3174 if (val) {
3175 if (csize) memcpy(val, cptr, csize*sizeof(char));
3176 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3177 }
3178 if (alloc == SWIG_NEWOBJ) {
3179 delete[] cptr;
3180 res = SWIG_DelNewMask(res);
3181 }
3182 return res;
3183 }
3184 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3185 }
3186 return SWIG_TypeError;
3187 }
3188
3189
3190 SWIGINTERN int
3191 SWIG_AsVal_char (PyObject * obj, char *val)
3192 {
3193 int res = SWIG_AsCharArray(obj, val, 1);
3194 if (!SWIG_IsOK(res)) {
3195 long v;
3196 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3197 if (SWIG_IsOK(res)) {
3198 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3199 if (val) *val = static_cast< char >(v);
3200 } else {
3201 res = SWIG_OverflowError;
3202 }
3203 }
3204 }
3205 return res;
3206 }
3207
3208 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3209 // We use only strings for the streams, not unicode
3210 PyObject* str = PyObject_Str(obj);
3211 if (! str) {
3212 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3213 return;
3214 }
3215 self->Write(PyString_AS_STRING(str),
3216 PyString_GET_SIZE(str));
3217 Py_DECREF(str);
3218 }
3219
3220 #include "wx/wxPython/pyistream.h"
3221
3222
3223 class wxPyFileSystemHandler : public wxFileSystemHandler
3224 {
3225 public:
3226 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3227
3228 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3229 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3230 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3231 DEC_PYCALLBACK_STRING__pure(FindNext);
3232
3233 wxString GetProtocol(const wxString& location) {
3234 return wxFileSystemHandler::GetProtocol(location);
3235 }
3236
3237 wxString GetLeftLocation(const wxString& location) {
3238 return wxFileSystemHandler::GetLeftLocation(location);
3239 }
3240
3241 wxString GetAnchor(const wxString& location) {
3242 return wxFileSystemHandler::GetAnchor(location);
3243 }
3244
3245 wxString GetRightLocation(const wxString& location) {
3246 return wxFileSystemHandler::GetRightLocation(location);
3247 }
3248
3249 wxString GetMimeTypeFromExt(const wxString& location) {
3250 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3251 }
3252
3253 PYPRIVATE;
3254 };
3255
3256
3257 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3258 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3259 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3260 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3261
3262
3263 SWIGINTERN int
3264 SWIG_AsVal_bool (PyObject *obj, bool *val)
3265 {
3266 if (obj == Py_True) {
3267 if (val) *val = true;
3268 return SWIG_OK;
3269 } else if (obj == Py_False) {
3270 if (val) *val = false;
3271 return SWIG_OK;
3272 } else {
3273 long v = 0;
3274 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3275 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3276 return res;
3277 }
3278 }
3279
3280 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3281 wxFileName fname = wxFileSystem::URLToFileName(url);
3282 return fname.GetFullPath();
3283 }
3284
3285 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3286 wxImage& image,
3287 long type) {
3288 wxMemoryFSHandler::AddFile(filename, image, type);
3289 }
3290
3291 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3292 const wxBitmap& bitmap,
3293 long type) {
3294 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3295 }
3296
3297 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3298 PyObject* data) {
3299 if (! PyString_Check(data)) {
3300 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3301 "Expected string object"));
3302 return;
3303 }
3304
3305 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3306 void* ptr = (void*)PyString_AsString(data);
3307 size_t size = PyString_Size(data);
3308 wxPyEndBlockThreads(blocked);
3309
3310 wxMemoryFSHandler::AddFile(filename, ptr, size);
3311 }
3312
3313
3314 #include "wx/wxPython/pyistream.h"
3315
3316
3317 SWIGINTERN int
3318 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3319 {
3320 long v = 0;
3321 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3322 return SWIG_TypeError;
3323 }
3324 else if (val)
3325 *val = (unsigned long)v;
3326 return SWIG_OK;
3327 }
3328
3329
3330 SWIGINTERN int
3331 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3332 {
3333 unsigned long v;
3334 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3335 if (SWIG_IsOK(res)) {
3336 if ((v > UCHAR_MAX)) {
3337 return SWIG_OverflowError;
3338 } else {
3339 if (val) *val = static_cast< unsigned char >(v);
3340 }
3341 }
3342 return res;
3343 }
3344
3345
3346 SWIGINTERNINLINE PyObject *
3347 SWIG_From_unsigned_SS_char (unsigned char value)
3348 {
3349 return SWIG_From_unsigned_SS_long (value);
3350 }
3351
3352 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3353 wxImageHistogramEntry e = (*self)[key];
3354 return e.value;
3355 }
3356 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3357 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3358 wxImageHistogramEntry e = (*self)[key];
3359 return e.value;
3360 }
3361 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3362 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3363 colour.Green(),
3364 colour.Blue());
3365 wxImageHistogramEntry e = (*self)[key];
3366 return e.value;
3367 }
3368
3369 typedef unsigned char* buffer;
3370
3371
3372 // Pull the nested class out to the top level for SWIG's sake
3373 #define wxImage_RGBValue wxImage::RGBValue
3374 #define wxImage_HSVValue wxImage::HSVValue
3375
3376 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3377 if (width > 0 && height > 0)
3378 return new wxImage(width, height, clear);
3379 else
3380 return new wxImage;
3381 }
3382 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3383 return new wxImage(bitmap.ConvertToImage());
3384 }
3385 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3386 if (DATASIZE != width*height*3) {
3387 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3388 return NULL;
3389 }
3390
3391 // Copy the source data so the wxImage can clean it up later
3392 buffer copy = (buffer)malloc(DATASIZE);
3393 if (copy == NULL) {
3394 wxPyBLOCK_THREADS(PyErr_NoMemory());
3395 return NULL;
3396 }
3397 memcpy(copy, data, DATASIZE);
3398 return new wxImage(width, height, copy, false);
3399 }
3400 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3401 if (DATASIZE != width*height*3) {
3402 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3403 return NULL;
3404 }
3405 if (ALPHASIZE != width*height) {
3406 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3407 return NULL;
3408 }
3409
3410 // Copy the source data so the wxImage can clean it up later
3411 buffer dcopy = (buffer)malloc(DATASIZE);
3412 if (dcopy == NULL) {
3413 wxPyBLOCK_THREADS(PyErr_NoMemory());
3414 return NULL;
3415 }
3416 memcpy(dcopy, data, DATASIZE);
3417
3418 buffer acopy = (buffer)malloc(ALPHASIZE);
3419 if (acopy == NULL) {
3420 wxPyBLOCK_THREADS(PyErr_NoMemory());
3421 return NULL;
3422 }
3423 memcpy(acopy, alpha, ALPHASIZE);
3424
3425 return new wxImage(width, height, dcopy, acopy, false);
3426 }
3427 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3428 wxSize size(self->GetWidth(), self->GetHeight());
3429 return size;
3430 }
3431 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3432 buffer data = self->GetData();
3433 int len = self->GetWidth() * self->GetHeight() * 3;
3434 PyObject* rv;
3435 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3436 return rv;
3437 }
3438 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3439 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3440 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3441 return;
3442 }
3443 buffer copy = (buffer)malloc(DATASIZE);
3444 if (copy == NULL) {
3445 wxPyBLOCK_THREADS(PyErr_NoMemory());
3446 return;
3447 }
3448 memcpy(copy, data, DATASIZE);
3449 self->SetData(copy, false);
3450 // wxImage takes ownership of copy...
3451 }
3452 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3453 buffer data = self->GetData();
3454 int len = self->GetWidth() * self->GetHeight() * 3;
3455 PyObject* rv;
3456 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3457 return rv;
3458 }
3459 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3460 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3461 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3462 return;
3463 }
3464 self->SetData(data, true);
3465 }
3466 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3467 buffer data = self->GetAlpha();
3468 if (! data) {
3469 RETURN_NONE();
3470 } else {
3471 int len = self->GetWidth() * self->GetHeight();
3472 PyObject* rv;
3473 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3474 return rv;
3475 }
3476 }
3477 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3478 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3479 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3480 return;
3481 }
3482 buffer acopy = (buffer)malloc(ALPHASIZE);
3483 if (acopy == NULL) {
3484 wxPyBLOCK_THREADS(PyErr_NoMemory());
3485 return;
3486 }
3487 memcpy(acopy, alpha, ALPHASIZE);
3488 self->SetAlpha(acopy, false);
3489 // wxImage takes ownership of acopy...
3490 }
3491 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3492 buffer data = self->GetAlpha();
3493 int len = self->GetWidth() * self->GetHeight();
3494 PyObject* rv;
3495 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3496 return rv;
3497 }
3498 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3499 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3500 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3501 return;
3502 }
3503 self->SetAlpha(alpha, true);
3504 }
3505 SWIGINTERN PyObject *wxImage_GetHandlers(){
3506 wxList& list = wxImage::GetHandlers();
3507 return wxPy_ConvertList(&list);
3508 }
3509 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3510 wxBitmap bitmap(*self, depth);
3511 return bitmap;
3512 }
3513 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3514 wxImage mono = self->ConvertToMono( red, green, blue );
3515 wxBitmap bitmap( mono, 1 );
3516 return bitmap;
3517 }
3518 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3519 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3520 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3521 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3522 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3523 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3524 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3525 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3526 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3527 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3528 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3529 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3530 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3531 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3532 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3533
3534 #include <wx/quantize.h>
3535
3536 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3537 return wxQuantize::Quantize(src, dest,
3538 //NULL, // palette
3539 desiredNoColours,
3540 NULL, // eightBitData
3541 flags);
3542 }
3543 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3544 if (PyCallable_Check(func)) {
3545 self->Connect(id, lastId, eventType,
3546 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3547 new wxPyCallback(func));
3548 }
3549 else if (func == Py_None) {
3550 self->Disconnect(id, lastId, eventType,
3551 (wxObjectEventFunction)
3552 &wxPyCallback::EventThunker);
3553 }
3554 else {
3555 wxPyBLOCK_THREADS(
3556 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3557 }
3558 }
3559 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3560 return self->Disconnect(id, lastId, eventType,
3561 (wxObjectEventFunction)
3562 &wxPyCallback::EventThunker);
3563 }
3564 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3565 if (_self && _self != Py_None) {
3566 self->SetClientObject(new wxPyOORClientData(_self, incref));
3567 }
3568 else {
3569 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3570 if (data) {
3571 self->SetClientObject(NULL); // This will delete it too
3572 }
3573 }
3574 }
3575
3576 #if ! wxUSE_HOTKEY
3577 #define wxEVT_HOTKEY -9999
3578 #endif
3579
3580 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3581 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3582 if (data) {
3583 Py_INCREF(data->m_obj);
3584 return data->m_obj;
3585 } else {
3586 Py_INCREF(Py_None);
3587 return Py_None;
3588 }
3589 }
3590 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3591 wxPyClientData* data = new wxPyClientData(clientData);
3592 self->SetClientObject(data);
3593 }
3594 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3595 #if wxUSE_UNICODE
3596 return self->GetUnicodeKey();
3597 #else
3598 return 0;
3599 #endif
3600 }
3601
3602 SWIGINTERNINLINE PyObject *
3603 SWIG_From_unsigned_SS_int (unsigned int value)
3604 {
3605 return SWIG_From_unsigned_SS_long (value);
3606 }
3607
3608
3609 SWIGINTERN int
3610 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3611 {
3612 unsigned long v;
3613 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3614 if (SWIG_IsOK(res)) {
3615 if ((v > UINT_MAX)) {
3616 return SWIG_OverflowError;
3617 } else {
3618 if (val) *val = static_cast< unsigned int >(v);
3619 }
3620 }
3621 return res;
3622 }
3623
3624 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3625 self->m_size = size;
3626 }
3627 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3628 int count = self->GetNumberOfFiles();
3629 wxString* files = self->GetFiles();
3630 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3631 PyObject* list = PyList_New(count);
3632
3633 if (!list) {
3634 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3635 wxPyEndBlockThreads(blocked);
3636 return NULL;
3637 }
3638
3639 for (int i=0; i<count; i++) {
3640 PyList_SetItem(list, i, wx2PyString(files[i]));
3641 }
3642 wxPyEndBlockThreads(blocked);
3643 return list;
3644 }
3645
3646
3647 SWIGINTERN wxPyApp *new_wxPyApp(){
3648 wxPythonApp = new wxPyApp();
3649 return wxPythonApp;
3650 }
3651 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3652
3653 void wxApp_CleanUp() {
3654 __wxPyCleanup();
3655 }
3656
3657
3658 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3659
3660
3661
3662
3663
3664 SWIGINTERNINLINE PyObject *
3665 SWIG_FromCharPtr(const char *cptr)
3666 {
3667 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3668 }
3669
3670
3671 #if 0 // #ifdef __WXMAC__
3672
3673 // A dummy class that raises an exception if used...
3674 class wxEventLoop
3675 {
3676 public:
3677 wxEventLoop() { wxPyRaiseNotImplemented(); }
3678 int Run() { return 0; }
3679 void Exit(int rc = 0) {}
3680 bool Pending() const { return false; }
3681 bool Dispatch() { return false; }
3682 bool IsRunning() const { return false; }
3683 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3684 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3685 };
3686
3687 #else
3688
3689 #include <wx/evtloop.h>
3690
3691 #endif
3692
3693
3694
3695 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3696 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3697 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3698 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3699 wxWindowList& list = self->GetChildren();
3700 return wxPy_ConvertList(&list);
3701 }
3702 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3703 #if wxUSE_HOTKEY
3704 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3705 #else
3706 return false;
3707 #endif
3708 }
3709 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3710
3711
3712
3713 return false;
3714
3715 }
3716 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3717 return wxPyGetWinHandle(self);
3718 }
3719 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3720 self->AssociateHandle((WXWidget)handle);
3721 }
3722 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3723
3724 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3725 return wxWindow::FindWindowById(id, parent);
3726 }
3727
3728 wxWindow* wxFindWindowByName( const wxString& name,
3729 const wxWindow *parent = NULL ) {
3730 return wxWindow::FindWindowByName(name, parent);
3731 }
3732
3733 wxWindow* wxFindWindowByLabel( const wxString& label,
3734 const wxWindow *parent = NULL ) {
3735 return wxWindow::FindWindowByLabel(label, parent);
3736 }
3737
3738
3739 #ifdef __WXMSW__
3740 #include <wx/msw/private.h> // to get wxGetWindowId
3741 #endif
3742
3743
3744 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3745 #ifdef __WXMSW__
3746 WXHWND hWnd = (WXHWND)_hWnd;
3747 long id = wxGetWindowId(hWnd);
3748 wxWindow* win = new wxWindow;
3749 if (parent)
3750 parent->AddChild(win);
3751 win->SetEventHandler(win);
3752 win->SetHWND(hWnd);
3753 win->SetId(id);
3754 win->SubclassWin(hWnd);
3755 win->AdoptAttributesFromHWND();
3756 win->SetupColours();
3757 return win;
3758 #else
3759 wxPyRaiseNotImplemented();
3760 return NULL;
3761 #endif
3762 }
3763
3764
3765 PyObject* GetTopLevelWindows() {
3766 return wxPy_ConvertList(&wxTopLevelWindows);
3767 }
3768
3769
3770 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3771 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3772 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3773
3774 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3775
3776
3777 SWIGINTERNINLINE int
3778 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3779 {
3780 unsigned long v;
3781 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3782 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3783 return res;
3784 }
3785
3786 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3787 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3788 wxMenuItemList& list = self->GetMenuItems();
3789 return wxPy_ConvertList(&list);
3790 }
3791 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3792 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3793 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3794 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3795 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3796 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3797 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3798 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3799 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3800 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3801 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3802 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3803 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3804 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3805 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3806 static const wxString wxPyControlNameStr(wxControlNameStr);
3807 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3808 if (clientData) {
3809 wxPyClientData* data = new wxPyClientData(clientData);
3810 return self->Append(item, data);
3811 } else
3812 return self->Append(item);
3813 }
3814 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3815 if (clientData) {
3816 wxPyClientData* data = new wxPyClientData(clientData);
3817 return self->Insert(item, pos, data);
3818 } else
3819 return self->Insert(item, pos);
3820 }
3821 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3822 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3823 if (data) {
3824 Py_INCREF(data->m_obj);
3825 return data->m_obj;
3826 } else {
3827 Py_INCREF(Py_None);
3828 return Py_None;
3829 }
3830 }
3831 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3832 wxPyClientData* data = new wxPyClientData(clientData);
3833 self->SetClientObject(n, data);
3834 }
3835
3836
3837 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3838 wxPyUserData* data = NULL;
3839 if ( userData ) {
3840 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3841 data = new wxPyUserData(userData);
3842 wxPyEndBlockThreads(blocked);
3843 }
3844 return new wxSizerItem(window, proportion, flag, border, data);
3845 }
3846 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3847 wxPyUserData* data = NULL;
3848 if ( userData ) {
3849 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3850 data = new wxPyUserData(userData);
3851 wxPyEndBlockThreads(blocked);
3852 }
3853 return new wxSizerItem(width, height, proportion, flag, border, data);
3854 }
3855 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3856 wxPyUserData* data = NULL;
3857 if ( userData ) {
3858 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3859 data = new wxPyUserData(userData);
3860 wxPyEndBlockThreads(blocked);
3861 }
3862 return new wxSizerItem(sizer, proportion, flag, border, data);
3863 }
3864
3865 #include <float.h>
3866
3867
3868 SWIGINTERN int
3869 SWIG_AsVal_float (PyObject * obj, float *val)
3870 {
3871 double v;
3872 int res = SWIG_AsVal_double (obj, &v);
3873 if (SWIG_IsOK(res)) {
3874 if ((v < -FLT_MAX || v > FLT_MAX)) {
3875 return SWIG_OverflowError;
3876 } else {
3877 if (val) *val = static_cast< float >(v);
3878 }
3879 }
3880 return res;
3881 }
3882
3883
3884 SWIGINTERNINLINE PyObject *
3885 SWIG_From_float (float value)
3886 {
3887 return SWIG_From_double (value);
3888 }
3889
3890 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3891 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3892 if (data) {
3893 Py_INCREF(data->m_obj);
3894 return data->m_obj;
3895 } else {
3896 Py_INCREF(Py_None);
3897 return Py_None;
3898 }
3899 }
3900 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3901 wxPyUserData* data = NULL;
3902 if ( userData ) {
3903 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3904 data = new wxPyUserData(userData);
3905 wxPyEndBlockThreads(blocked);
3906 }
3907 self->SetUserData(data);
3908 }
3909
3910 // Figure out the type of the sizer item
3911
3912 struct wxPySizerItemInfo {
3913 wxPySizerItemInfo()
3914 : window(NULL), sizer(NULL), gotSize(false),
3915 size(wxDefaultSize), gotPos(false), pos(-1)
3916 {}
3917
3918 wxWindow* window;
3919 wxSizer* sizer;
3920 bool gotSize;
3921 wxSize size;
3922 bool gotPos;
3923 int pos;
3924 };
3925
3926 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3927
3928 wxPySizerItemInfo info;
3929 wxSize size;
3930 wxSize* sizePtr = &size;
3931
3932 // Find out what the type of the item is
3933 // try wxWindow
3934 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3935 PyErr_Clear();
3936 info.window = NULL;
3937
3938 // try wxSizer
3939 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3940 PyErr_Clear();
3941 info.sizer = NULL;
3942
3943 // try wxSize or (w,h)
3944 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3945 info.size = *sizePtr;
3946 info.gotSize = true;
3947 }
3948
3949 // or a single int
3950 if (checkIdx && PyInt_Check(item)) {
3951 info.pos = PyInt_AsLong(item);
3952 info.gotPos = true;
3953 }
3954 }
3955 }
3956
3957 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3958 // no expected type, figure out what kind of error message to generate
3959 if ( !checkSize && !checkIdx )
3960 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3961 else if ( checkSize && !checkIdx )
3962 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3963 else if ( !checkSize && checkIdx)
3964 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3965 else
3966 // can this one happen?
3967 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3968 }
3969
3970 return info;
3971 }
3972
3973 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3974 if (!self->GetClientObject())
3975 self->SetClientObject(new wxPyOORClientData(_self));
3976 }
3977 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3978
3979 wxPyUserData* data = NULL;
3980 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3981 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3982 if ( userData && (info.window || info.sizer || info.gotSize) )
3983 data = new wxPyUserData(userData);
3984 if ( info.sizer )
3985 PyObject_SetAttrString(item,"thisown",Py_False);
3986 wxPyEndBlockThreads(blocked);
3987
3988 // Now call the real Add method if a valid item type was found
3989 if ( info.window )
3990 return self->Add(info.window, proportion, flag, border, data);
3991 else if ( info.sizer )
3992 return self->Add(info.sizer, proportion, flag, border, data);
3993 else if (info.gotSize)
3994 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3995 proportion, flag, border, data);
3996 else
3997 return NULL;
3998 }
3999 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4000
4001 wxPyUserData* data = NULL;
4002 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4003 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4004 if ( userData && (info.window || info.sizer || info.gotSize) )
4005 data = new wxPyUserData(userData);
4006 if ( info.sizer )
4007 PyObject_SetAttrString(item,"thisown",Py_False);
4008 wxPyEndBlockThreads(blocked);
4009
4010 // Now call the real Insert method if a valid item type was found
4011 if ( info.window )
4012 return self->Insert(before, info.window, proportion, flag, border, data);
4013 else if ( info.sizer )
4014 return self->Insert(before, info.sizer, proportion, flag, border, data);
4015 else if (info.gotSize)
4016 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4017 proportion, flag, border, data);
4018 else
4019 return NULL;
4020 }
4021 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4022
4023 wxPyUserData* data = NULL;
4024 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4025 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4026 if ( userData && (info.window || info.sizer || info.gotSize) )
4027 data = new wxPyUserData(userData);
4028 if ( info.sizer )
4029 PyObject_SetAttrString(item,"thisown",Py_False);
4030 wxPyEndBlockThreads(blocked);
4031
4032 // Now call the real Prepend method if a valid item type was found
4033 if ( info.window )
4034 return self->Prepend(info.window, proportion, flag, border, data);
4035 else if ( info.sizer )
4036 return self->Prepend(info.sizer, proportion, flag, border, data);
4037 else if (info.gotSize)
4038 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4039 proportion, flag, border, data);
4040 else
4041 return NULL;
4042 }
4043 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4045 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4046 wxPyEndBlockThreads(blocked);
4047 if ( info.window )
4048 return self->Remove(info.window);
4049 else if ( info.sizer )
4050 return self->Remove(info.sizer);
4051 else if ( info.gotPos )
4052 return self->Remove(info.pos);
4053 else
4054 return false;
4055 }
4056 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4057 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4058 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4059 wxPyEndBlockThreads(blocked);
4060 if ( info.window )
4061 return self->Detach(info.window);
4062 else if ( info.sizer )
4063 return self->Detach(info.sizer);
4064 else if ( info.gotPos )
4065 return self->Detach(info.pos);
4066 else
4067 return false;
4068 }
4069 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4071 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4072 wxPyEndBlockThreads(blocked);
4073 if ( info.window )
4074 return self->GetItem(info.window);
4075 else if ( info.sizer )
4076 return self->GetItem(info.sizer);
4077 else if ( info.gotPos )
4078 return self->GetItem(info.pos);
4079 else
4080 return NULL;
4081 }
4082 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4085 wxPyEndBlockThreads(blocked);
4086 if ( info.window )
4087 self->SetItemMinSize(info.window, size);
4088 else if ( info.sizer )
4089 self->SetItemMinSize(info.sizer, size);
4090 else if ( info.gotPos )
4091 self->SetItemMinSize(info.pos, size);
4092 }
4093 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4094 wxSizerItemList& list = self->GetChildren();
4095 return wxPy_ConvertList(&list);
4096 }
4097 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4098 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4099 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4100 wxPyEndBlockThreads(blocked);
4101 if ( info.window )
4102 return self->Show(info.window, show, recursive);
4103 else if ( info.sizer )
4104 return self->Show(info.sizer, show, recursive);
4105 else if ( info.gotPos )
4106 return self->Show(info.pos, show);
4107 else
4108 return false;
4109 }
4110 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4111 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4112 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4113 wxPyEndBlockThreads(blocked);
4114 if ( info.window )
4115 return self->IsShown(info.window);
4116 else if ( info.sizer )
4117 return self->IsShown(info.sizer);
4118 else if ( info.gotPos )
4119 return self->IsShown(info.pos);
4120 else
4121 return false;
4122 }
4123
4124 // See pyclasses.h
4125 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4126 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4127 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4128
4129
4130
4131
4132 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4133 {
4134 if (source == Py_None) {
4135 **obj = wxGBPosition(-1,-1);
4136 return true;
4137 }
4138 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4139 }
4140
4141 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4142 {
4143 if (source == Py_None) {
4144 **obj = wxGBSpan(-1,-1);
4145 return true;
4146 }
4147 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4148 }
4149
4150
4151 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4152 self->SetRow(row);
4153 self->SetCol(col);
4154 }
4155 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4156 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4157 PyObject* tup = PyTuple_New(2);
4158 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4159 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4160 wxPyEndBlockThreads(blocked);
4161 return tup;
4162 }
4163 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4164 self->SetRowspan(rowspan);
4165 self->SetColspan(colspan);
4166 }
4167 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4168 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4169 PyObject* tup = PyTuple_New(2);
4170 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4171 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4172 wxPyEndBlockThreads(blocked);
4173 return tup;
4174 }
4175 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4176 wxPyUserData* data = NULL;
4177 if ( userData ) {
4178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4179 data = new wxPyUserData(userData);
4180 wxPyEndBlockThreads(blocked);
4181 }
4182 return new wxGBSizerItem(window, pos, span, flag, border, data);
4183 }
4184 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4185 wxPyUserData* data = NULL;
4186 if ( userData ) {
4187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4188 data = new wxPyUserData(userData);
4189 wxPyEndBlockThreads(blocked);
4190 }
4191 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4192 }
4193 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4194 wxPyUserData* data = NULL;
4195 if ( userData ) {
4196 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4197 data = new wxPyUserData(userData);
4198 wxPyEndBlockThreads(blocked);
4199 }
4200 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4201 }
4202 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4203 int row, col;
4204 self->GetEndPos(row, col);
4205 return wxGBPosition(row, col);
4206 }
4207 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4208
4209 wxPyUserData* data = NULL;
4210 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4211 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4212 if ( userData && (info.window || info.sizer || info.gotSize) )
4213 data = new wxPyUserData(userData);
4214 if ( info.sizer )
4215 PyObject_SetAttrString(item,"thisown",Py_False);
4216 wxPyEndBlockThreads(blocked);
4217
4218 // Now call the real Add method if a valid item type was found
4219 if ( info.window )
4220 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4221 else if ( info.sizer )
4222 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4223 else if (info.gotSize)
4224 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4225 pos, span, flag, border, data);
4226 return NULL;
4227 }
4228
4229
4230 #ifdef __cplusplus
4231 extern "C" {
4232 #endif
4233 SWIGINTERN int EmptyString_set(PyObject *) {
4234 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4235 return 1;
4236 }
4237
4238
4239 SWIGINTERN PyObject *EmptyString_get(void) {
4240 PyObject *pyobj = 0;
4241
4242 {
4243 #if wxUSE_UNICODE
4244 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4245 #else
4246 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4247 #endif
4248 }
4249 return pyobj;
4250 }
4251
4252
4253 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4254 PyObject *resultobj = 0;
4255 wxObject *arg1 = (wxObject *) 0 ;
4256 wxString result;
4257 void *argp1 = 0 ;
4258 int res1 = 0 ;
4259 PyObject *swig_obj[1] ;
4260
4261 if (!args) SWIG_fail;
4262 swig_obj[0] = args;
4263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4264 if (!SWIG_IsOK(res1)) {
4265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4266 }
4267 arg1 = reinterpret_cast< wxObject * >(argp1);
4268 {
4269 PyThreadState* __tstate = wxPyBeginAllowThreads();
4270 result = wxObject_GetClassName(arg1);
4271 wxPyEndAllowThreads(__tstate);
4272 if (PyErr_Occurred()) SWIG_fail;
4273 }
4274 {
4275 #if wxUSE_UNICODE
4276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4277 #else
4278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4279 #endif
4280 }
4281 return resultobj;
4282 fail:
4283 return NULL;
4284 }
4285
4286
4287 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4288 PyObject *resultobj = 0;
4289 wxObject *arg1 = (wxObject *) 0 ;
4290 void *argp1 = 0 ;
4291 int res1 = 0 ;
4292 PyObject *swig_obj[1] ;
4293
4294 if (!args) SWIG_fail;
4295 swig_obj[0] = args;
4296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4297 if (!SWIG_IsOK(res1)) {
4298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4299 }
4300 arg1 = reinterpret_cast< wxObject * >(argp1);
4301 {
4302 PyThreadState* __tstate = wxPyBeginAllowThreads();
4303 wxObject_Destroy(arg1);
4304 wxPyEndAllowThreads(__tstate);
4305 if (PyErr_Occurred()) SWIG_fail;
4306 }
4307 resultobj = SWIG_Py_Void();
4308 return resultobj;
4309 fail:
4310 return NULL;
4311 }
4312
4313
4314 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4315 PyObject *obj;
4316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4317 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4318 return SWIG_Py_Void();
4319 }
4320
4321 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4322 PyObject *resultobj = 0;
4323 wxSize *arg1 = (wxSize *) 0 ;
4324 int arg2 ;
4325 void *argp1 = 0 ;
4326 int res1 = 0 ;
4327 int val2 ;
4328 int ecode2 = 0 ;
4329 PyObject *swig_obj[2] ;
4330
4331 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4333 if (!SWIG_IsOK(res1)) {
4334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4335 }
4336 arg1 = reinterpret_cast< wxSize * >(argp1);
4337 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4338 if (!SWIG_IsOK(ecode2)) {
4339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4340 }
4341 arg2 = static_cast< int >(val2);
4342 if (arg1) (arg1)->x = arg2;
4343
4344 resultobj = SWIG_Py_Void();
4345 return resultobj;
4346 fail:
4347 return NULL;
4348 }
4349
4350
4351 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4352 PyObject *resultobj = 0;
4353 wxSize *arg1 = (wxSize *) 0 ;
4354 int result;
4355 void *argp1 = 0 ;
4356 int res1 = 0 ;
4357 PyObject *swig_obj[1] ;
4358
4359 if (!args) SWIG_fail;
4360 swig_obj[0] = args;
4361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4362 if (!SWIG_IsOK(res1)) {
4363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4364 }
4365 arg1 = reinterpret_cast< wxSize * >(argp1);
4366 result = (int) ((arg1)->x);
4367 resultobj = SWIG_From_int(static_cast< int >(result));
4368 return resultobj;
4369 fail:
4370 return NULL;
4371 }
4372
4373
4374 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4375 PyObject *resultobj = 0;
4376 wxSize *arg1 = (wxSize *) 0 ;
4377 int arg2 ;
4378 void *argp1 = 0 ;
4379 int res1 = 0 ;
4380 int val2 ;
4381 int ecode2 = 0 ;
4382 PyObject *swig_obj[2] ;
4383
4384 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4386 if (!SWIG_IsOK(res1)) {
4387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4388 }
4389 arg1 = reinterpret_cast< wxSize * >(argp1);
4390 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4391 if (!SWIG_IsOK(ecode2)) {
4392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4393 }
4394 arg2 = static_cast< int >(val2);
4395 if (arg1) (arg1)->y = arg2;
4396
4397 resultobj = SWIG_Py_Void();
4398 return resultobj;
4399 fail:
4400 return NULL;
4401 }
4402
4403
4404 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4405 PyObject *resultobj = 0;
4406 wxSize *arg1 = (wxSize *) 0 ;
4407 int result;
4408 void *argp1 = 0 ;
4409 int res1 = 0 ;
4410 PyObject *swig_obj[1] ;
4411
4412 if (!args) SWIG_fail;
4413 swig_obj[0] = args;
4414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4415 if (!SWIG_IsOK(res1)) {
4416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4417 }
4418 arg1 = reinterpret_cast< wxSize * >(argp1);
4419 result = (int) ((arg1)->y);
4420 resultobj = SWIG_From_int(static_cast< int >(result));
4421 return resultobj;
4422 fail:
4423 return NULL;
4424 }
4425
4426
4427 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4428 PyObject *resultobj = 0;
4429 int arg1 = (int) 0 ;
4430 int arg2 = (int) 0 ;
4431 wxSize *result = 0 ;
4432 int val1 ;
4433 int ecode1 = 0 ;
4434 int val2 ;
4435 int ecode2 = 0 ;
4436 PyObject * obj0 = 0 ;
4437 PyObject * obj1 = 0 ;
4438 char * kwnames[] = {
4439 (char *) "w",(char *) "h", NULL
4440 };
4441
4442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4443 if (obj0) {
4444 ecode1 = SWIG_AsVal_int(obj0, &val1);
4445 if (!SWIG_IsOK(ecode1)) {
4446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4447 }
4448 arg1 = static_cast< int >(val1);
4449 }
4450 if (obj1) {
4451 ecode2 = SWIG_AsVal_int(obj1, &val2);
4452 if (!SWIG_IsOK(ecode2)) {
4453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4454 }
4455 arg2 = static_cast< int >(val2);
4456 }
4457 {
4458 PyThreadState* __tstate = wxPyBeginAllowThreads();
4459 result = (wxSize *)new wxSize(arg1,arg2);
4460 wxPyEndAllowThreads(__tstate);
4461 if (PyErr_Occurred()) SWIG_fail;
4462 }
4463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4464 return resultobj;
4465 fail:
4466 return NULL;
4467 }
4468
4469
4470 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4471 PyObject *resultobj = 0;
4472 wxSize *arg1 = (wxSize *) 0 ;
4473 void *argp1 = 0 ;
4474 int res1 = 0 ;
4475 PyObject *swig_obj[1] ;
4476
4477 if (!args) SWIG_fail;
4478 swig_obj[0] = args;
4479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4480 if (!SWIG_IsOK(res1)) {
4481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4482 }
4483 arg1 = reinterpret_cast< wxSize * >(argp1);
4484 {
4485 PyThreadState* __tstate = wxPyBeginAllowThreads();
4486 delete arg1;
4487
4488 wxPyEndAllowThreads(__tstate);
4489 if (PyErr_Occurred()) SWIG_fail;
4490 }
4491 resultobj = SWIG_Py_Void();
4492 return resultobj;
4493 fail:
4494 return NULL;
4495 }
4496
4497
4498 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4499 PyObject *resultobj = 0;
4500 wxSize *arg1 = (wxSize *) 0 ;
4501 wxSize *arg2 = 0 ;
4502 bool result;
4503 void *argp1 = 0 ;
4504 int res1 = 0 ;
4505 wxSize temp2 ;
4506 PyObject * obj0 = 0 ;
4507 PyObject * obj1 = 0 ;
4508 char * kwnames[] = {
4509 (char *) "self",(char *) "sz", NULL
4510 };
4511
4512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4514 if (!SWIG_IsOK(res1)) {
4515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4516 }
4517 arg1 = reinterpret_cast< wxSize * >(argp1);
4518 {
4519 arg2 = &temp2;
4520 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4521 }
4522 {
4523 PyThreadState* __tstate = wxPyBeginAllowThreads();
4524 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
4525 wxPyEndAllowThreads(__tstate);
4526 if (PyErr_Occurred()) SWIG_fail;
4527 }
4528 {
4529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4530 }
4531 return resultobj;
4532 fail:
4533 return NULL;
4534 }
4535
4536
4537 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4538 PyObject *resultobj = 0;
4539 wxSize *arg1 = (wxSize *) 0 ;
4540 wxSize *arg2 = 0 ;
4541 bool result;
4542 void *argp1 = 0 ;
4543 int res1 = 0 ;
4544 wxSize temp2 ;
4545 PyObject * obj0 = 0 ;
4546 PyObject * obj1 = 0 ;
4547 char * kwnames[] = {
4548 (char *) "self",(char *) "sz", NULL
4549 };
4550
4551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4553 if (!SWIG_IsOK(res1)) {
4554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4555 }
4556 arg1 = reinterpret_cast< wxSize * >(argp1);
4557 {
4558 arg2 = &temp2;
4559 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4560 }
4561 {
4562 PyThreadState* __tstate = wxPyBeginAllowThreads();
4563 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
4564 wxPyEndAllowThreads(__tstate);
4565 if (PyErr_Occurred()) SWIG_fail;
4566 }
4567 {
4568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4569 }
4570 return resultobj;
4571 fail:
4572 return NULL;
4573 }
4574
4575
4576 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4577 PyObject *resultobj = 0;
4578 wxSize *arg1 = (wxSize *) 0 ;
4579 wxSize *arg2 = 0 ;
4580 wxSize result;
4581 void *argp1 = 0 ;
4582 int res1 = 0 ;
4583 wxSize temp2 ;
4584 PyObject * obj0 = 0 ;
4585 PyObject * obj1 = 0 ;
4586 char * kwnames[] = {
4587 (char *) "self",(char *) "sz", NULL
4588 };
4589
4590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4592 if (!SWIG_IsOK(res1)) {
4593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4594 }
4595 arg1 = reinterpret_cast< wxSize * >(argp1);
4596 {
4597 arg2 = &temp2;
4598 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4599 }
4600 {
4601 PyThreadState* __tstate = wxPyBeginAllowThreads();
4602 result = (arg1)->operator +((wxSize const &)*arg2);
4603 wxPyEndAllowThreads(__tstate);
4604 if (PyErr_Occurred()) SWIG_fail;
4605 }
4606 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4607 return resultobj;
4608 fail:
4609 return NULL;
4610 }
4611
4612
4613 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4614 PyObject *resultobj = 0;
4615 wxSize *arg1 = (wxSize *) 0 ;
4616 wxSize *arg2 = 0 ;
4617 wxSize result;
4618 void *argp1 = 0 ;
4619 int res1 = 0 ;
4620 wxSize temp2 ;
4621 PyObject * obj0 = 0 ;
4622 PyObject * obj1 = 0 ;
4623 char * kwnames[] = {
4624 (char *) "self",(char *) "sz", NULL
4625 };
4626
4627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4629 if (!SWIG_IsOK(res1)) {
4630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4631 }
4632 arg1 = reinterpret_cast< wxSize * >(argp1);
4633 {
4634 arg2 = &temp2;
4635 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4636 }
4637 {
4638 PyThreadState* __tstate = wxPyBeginAllowThreads();
4639 result = (arg1)->operator -((wxSize const &)*arg2);
4640 wxPyEndAllowThreads(__tstate);
4641 if (PyErr_Occurred()) SWIG_fail;
4642 }
4643 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4644 return resultobj;
4645 fail:
4646 return NULL;
4647 }
4648
4649
4650 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4651 PyObject *resultobj = 0;
4652 wxSize *arg1 = (wxSize *) 0 ;
4653 wxSize *arg2 = 0 ;
4654 void *argp1 = 0 ;
4655 int res1 = 0 ;
4656 wxSize temp2 ;
4657 PyObject * obj0 = 0 ;
4658 PyObject * obj1 = 0 ;
4659 char * kwnames[] = {
4660 (char *) "self",(char *) "sz", NULL
4661 };
4662
4663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4665 if (!SWIG_IsOK(res1)) {
4666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4667 }
4668 arg1 = reinterpret_cast< wxSize * >(argp1);
4669 {
4670 arg2 = &temp2;
4671 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4672 }
4673 {
4674 PyThreadState* __tstate = wxPyBeginAllowThreads();
4675 (arg1)->IncTo((wxSize const &)*arg2);
4676 wxPyEndAllowThreads(__tstate);
4677 if (PyErr_Occurred()) SWIG_fail;
4678 }
4679 resultobj = SWIG_Py_Void();
4680 return resultobj;
4681 fail:
4682 return NULL;
4683 }
4684
4685
4686 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4687 PyObject *resultobj = 0;
4688 wxSize *arg1 = (wxSize *) 0 ;
4689 wxSize *arg2 = 0 ;
4690 void *argp1 = 0 ;
4691 int res1 = 0 ;
4692 wxSize temp2 ;
4693 PyObject * obj0 = 0 ;
4694 PyObject * obj1 = 0 ;
4695 char * kwnames[] = {
4696 (char *) "self",(char *) "sz", NULL
4697 };
4698
4699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4701 if (!SWIG_IsOK(res1)) {
4702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4703 }
4704 arg1 = reinterpret_cast< wxSize * >(argp1);
4705 {
4706 arg2 = &temp2;
4707 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4708 }
4709 {
4710 PyThreadState* __tstate = wxPyBeginAllowThreads();
4711 (arg1)->DecTo((wxSize const &)*arg2);
4712 wxPyEndAllowThreads(__tstate);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 resultobj = SWIG_Py_Void();
4716 return resultobj;
4717 fail:
4718 return NULL;
4719 }
4720
4721
4722 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4723 PyObject *resultobj = 0;
4724 wxSize *arg1 = (wxSize *) 0 ;
4725 int arg2 ;
4726 int arg3 ;
4727 void *argp1 = 0 ;
4728 int res1 = 0 ;
4729 int val2 ;
4730 int ecode2 = 0 ;
4731 int val3 ;
4732 int ecode3 = 0 ;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 PyObject * obj2 = 0 ;
4736 char * kwnames[] = {
4737 (char *) "self",(char *) "w",(char *) "h", NULL
4738 };
4739
4740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4742 if (!SWIG_IsOK(res1)) {
4743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4744 }
4745 arg1 = reinterpret_cast< wxSize * >(argp1);
4746 ecode2 = SWIG_AsVal_int(obj1, &val2);
4747 if (!SWIG_IsOK(ecode2)) {
4748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4749 }
4750 arg2 = static_cast< int >(val2);
4751 ecode3 = SWIG_AsVal_int(obj2, &val3);
4752 if (!SWIG_IsOK(ecode3)) {
4753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4754 }
4755 arg3 = static_cast< int >(val3);
4756 {
4757 PyThreadState* __tstate = wxPyBeginAllowThreads();
4758 (arg1)->Set(arg2,arg3);
4759 wxPyEndAllowThreads(__tstate);
4760 if (PyErr_Occurred()) SWIG_fail;
4761 }
4762 resultobj = SWIG_Py_Void();
4763 return resultobj;
4764 fail:
4765 return NULL;
4766 }
4767
4768
4769 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4770 PyObject *resultobj = 0;
4771 wxSize *arg1 = (wxSize *) 0 ;
4772 int arg2 ;
4773 void *argp1 = 0 ;
4774 int res1 = 0 ;
4775 int val2 ;
4776 int ecode2 = 0 ;
4777 PyObject * obj0 = 0 ;
4778 PyObject * obj1 = 0 ;
4779 char * kwnames[] = {
4780 (char *) "self",(char *) "w", NULL
4781 };
4782
4783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4785 if (!SWIG_IsOK(res1)) {
4786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4787 }
4788 arg1 = reinterpret_cast< wxSize * >(argp1);
4789 ecode2 = SWIG_AsVal_int(obj1, &val2);
4790 if (!SWIG_IsOK(ecode2)) {
4791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4792 }
4793 arg2 = static_cast< int >(val2);
4794 {
4795 PyThreadState* __tstate = wxPyBeginAllowThreads();
4796 (arg1)->SetWidth(arg2);
4797 wxPyEndAllowThreads(__tstate);
4798 if (PyErr_Occurred()) SWIG_fail;
4799 }
4800 resultobj = SWIG_Py_Void();
4801 return resultobj;
4802 fail:
4803 return NULL;
4804 }
4805
4806
4807 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4808 PyObject *resultobj = 0;
4809 wxSize *arg1 = (wxSize *) 0 ;
4810 int arg2 ;
4811 void *argp1 = 0 ;
4812 int res1 = 0 ;
4813 int val2 ;
4814 int ecode2 = 0 ;
4815 PyObject * obj0 = 0 ;
4816 PyObject * obj1 = 0 ;
4817 char * kwnames[] = {
4818 (char *) "self",(char *) "h", NULL
4819 };
4820
4821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4823 if (!SWIG_IsOK(res1)) {
4824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4825 }
4826 arg1 = reinterpret_cast< wxSize * >(argp1);
4827 ecode2 = SWIG_AsVal_int(obj1, &val2);
4828 if (!SWIG_IsOK(ecode2)) {
4829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4830 }
4831 arg2 = static_cast< int >(val2);
4832 {
4833 PyThreadState* __tstate = wxPyBeginAllowThreads();
4834 (arg1)->SetHeight(arg2);
4835 wxPyEndAllowThreads(__tstate);
4836 if (PyErr_Occurred()) SWIG_fail;
4837 }
4838 resultobj = SWIG_Py_Void();
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4846 PyObject *resultobj = 0;
4847 wxSize *arg1 = (wxSize *) 0 ;
4848 int result;
4849 void *argp1 = 0 ;
4850 int res1 = 0 ;
4851 PyObject *swig_obj[1] ;
4852
4853 if (!args) SWIG_fail;
4854 swig_obj[0] = args;
4855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4856 if (!SWIG_IsOK(res1)) {
4857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4858 }
4859 arg1 = reinterpret_cast< wxSize * >(argp1);
4860 {
4861 PyThreadState* __tstate = wxPyBeginAllowThreads();
4862 result = (int)((wxSize const *)arg1)->GetWidth();
4863 wxPyEndAllowThreads(__tstate);
4864 if (PyErr_Occurred()) SWIG_fail;
4865 }
4866 resultobj = SWIG_From_int(static_cast< int >(result));
4867 return resultobj;
4868 fail:
4869 return NULL;
4870 }
4871
4872
4873 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4874 PyObject *resultobj = 0;
4875 wxSize *arg1 = (wxSize *) 0 ;
4876 int result;
4877 void *argp1 = 0 ;
4878 int res1 = 0 ;
4879 PyObject *swig_obj[1] ;
4880
4881 if (!args) SWIG_fail;
4882 swig_obj[0] = args;
4883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4884 if (!SWIG_IsOK(res1)) {
4885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4886 }
4887 arg1 = reinterpret_cast< wxSize * >(argp1);
4888 {
4889 PyThreadState* __tstate = wxPyBeginAllowThreads();
4890 result = (int)((wxSize const *)arg1)->GetHeight();
4891 wxPyEndAllowThreads(__tstate);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_From_int(static_cast< int >(result));
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4902 PyObject *resultobj = 0;
4903 wxSize *arg1 = (wxSize *) 0 ;
4904 bool result;
4905 void *argp1 = 0 ;
4906 int res1 = 0 ;
4907 PyObject *swig_obj[1] ;
4908
4909 if (!args) SWIG_fail;
4910 swig_obj[0] = args;
4911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4912 if (!SWIG_IsOK(res1)) {
4913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
4914 }
4915 arg1 = reinterpret_cast< wxSize * >(argp1);
4916 {
4917 PyThreadState* __tstate = wxPyBeginAllowThreads();
4918 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4919 wxPyEndAllowThreads(__tstate);
4920 if (PyErr_Occurred()) SWIG_fail;
4921 }
4922 {
4923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4924 }
4925 return resultobj;
4926 fail:
4927 return NULL;
4928 }
4929
4930
4931 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4932 PyObject *resultobj = 0;
4933 wxSize *arg1 = (wxSize *) 0 ;
4934 wxSize *arg2 = 0 ;
4935 void *argp1 = 0 ;
4936 int res1 = 0 ;
4937 wxSize temp2 ;
4938 PyObject * obj0 = 0 ;
4939 PyObject * obj1 = 0 ;
4940 char * kwnames[] = {
4941 (char *) "self",(char *) "size", NULL
4942 };
4943
4944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
4945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4946 if (!SWIG_IsOK(res1)) {
4947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
4948 }
4949 arg1 = reinterpret_cast< wxSize * >(argp1);
4950 {
4951 arg2 = &temp2;
4952 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4953 }
4954 {
4955 PyThreadState* __tstate = wxPyBeginAllowThreads();
4956 (arg1)->SetDefaults((wxSize const &)*arg2);
4957 wxPyEndAllowThreads(__tstate);
4958 if (PyErr_Occurred()) SWIG_fail;
4959 }
4960 resultobj = SWIG_Py_Void();
4961 return resultobj;
4962 fail:
4963 return NULL;
4964 }
4965
4966
4967 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4968 PyObject *resultobj = 0;
4969 wxSize *arg1 = (wxSize *) 0 ;
4970 PyObject *result = 0 ;
4971 void *argp1 = 0 ;
4972 int res1 = 0 ;
4973 PyObject *swig_obj[1] ;
4974
4975 if (!args) SWIG_fail;
4976 swig_obj[0] = args;
4977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4978 if (!SWIG_IsOK(res1)) {
4979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
4980 }
4981 arg1 = reinterpret_cast< wxSize * >(argp1);
4982 {
4983 PyThreadState* __tstate = wxPyBeginAllowThreads();
4984 result = (PyObject *)wxSize_Get(arg1);
4985 wxPyEndAllowThreads(__tstate);
4986 if (PyErr_Occurred()) SWIG_fail;
4987 }
4988 resultobj = result;
4989 return resultobj;
4990 fail:
4991 return NULL;
4992 }
4993
4994
4995 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4996 PyObject *obj;
4997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4998 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
4999 return SWIG_Py_Void();
5000 }
5001
5002 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5003 return SWIG_Python_InitShadowInstance(args);
5004 }
5005
5006 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5007 PyObject *resultobj = 0;
5008 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5009 double arg2 ;
5010 void *argp1 = 0 ;
5011 int res1 = 0 ;
5012 double val2 ;
5013 int ecode2 = 0 ;
5014 PyObject *swig_obj[2] ;
5015
5016 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5018 if (!SWIG_IsOK(res1)) {
5019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5020 }
5021 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5022 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5023 if (!SWIG_IsOK(ecode2)) {
5024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5025 }
5026 arg2 = static_cast< double >(val2);
5027 if (arg1) (arg1)->x = arg2;
5028
5029 resultobj = SWIG_Py_Void();
5030 return resultobj;
5031 fail:
5032 return NULL;
5033 }
5034
5035
5036 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5037 PyObject *resultobj = 0;
5038 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5039 double result;
5040 void *argp1 = 0 ;
5041 int res1 = 0 ;
5042 PyObject *swig_obj[1] ;
5043
5044 if (!args) SWIG_fail;
5045 swig_obj[0] = args;
5046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5047 if (!SWIG_IsOK(res1)) {
5048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5049 }
5050 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5051 result = (double) ((arg1)->x);
5052 resultobj = SWIG_From_double(static_cast< double >(result));
5053 return resultobj;
5054 fail:
5055 return NULL;
5056 }
5057
5058
5059 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5060 PyObject *resultobj = 0;
5061 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5062 double arg2 ;
5063 void *argp1 = 0 ;
5064 int res1 = 0 ;
5065 double val2 ;
5066 int ecode2 = 0 ;
5067 PyObject *swig_obj[2] ;
5068
5069 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5071 if (!SWIG_IsOK(res1)) {
5072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5073 }
5074 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5075 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5076 if (!SWIG_IsOK(ecode2)) {
5077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5078 }
5079 arg2 = static_cast< double >(val2);
5080 if (arg1) (arg1)->y = arg2;
5081
5082 resultobj = SWIG_Py_Void();
5083 return resultobj;
5084 fail:
5085 return NULL;
5086 }
5087
5088
5089 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5090 PyObject *resultobj = 0;
5091 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5092 double result;
5093 void *argp1 = 0 ;
5094 int res1 = 0 ;
5095 PyObject *swig_obj[1] ;
5096
5097 if (!args) SWIG_fail;
5098 swig_obj[0] = args;
5099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5100 if (!SWIG_IsOK(res1)) {
5101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5102 }
5103 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5104 result = (double) ((arg1)->y);
5105 resultobj = SWIG_From_double(static_cast< double >(result));
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5113 PyObject *resultobj = 0;
5114 double arg1 = (double) 0.0 ;
5115 double arg2 = (double) 0.0 ;
5116 wxRealPoint *result = 0 ;
5117 double val1 ;
5118 int ecode1 = 0 ;
5119 double val2 ;
5120 int ecode2 = 0 ;
5121 PyObject * obj0 = 0 ;
5122 PyObject * obj1 = 0 ;
5123 char * kwnames[] = {
5124 (char *) "x",(char *) "y", NULL
5125 };
5126
5127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5128 if (obj0) {
5129 ecode1 = SWIG_AsVal_double(obj0, &val1);
5130 if (!SWIG_IsOK(ecode1)) {
5131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5132 }
5133 arg1 = static_cast< double >(val1);
5134 }
5135 if (obj1) {
5136 ecode2 = SWIG_AsVal_double(obj1, &val2);
5137 if (!SWIG_IsOK(ecode2)) {
5138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5139 }
5140 arg2 = static_cast< double >(val2);
5141 }
5142 {
5143 PyThreadState* __tstate = wxPyBeginAllowThreads();
5144 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5145 wxPyEndAllowThreads(__tstate);
5146 if (PyErr_Occurred()) SWIG_fail;
5147 }
5148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5149 return resultobj;
5150 fail:
5151 return NULL;
5152 }
5153
5154
5155 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5156 PyObject *resultobj = 0;
5157 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5158 void *argp1 = 0 ;
5159 int res1 = 0 ;
5160 PyObject *swig_obj[1] ;
5161
5162 if (!args) SWIG_fail;
5163 swig_obj[0] = args;
5164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5165 if (!SWIG_IsOK(res1)) {
5166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5167 }
5168 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5169 {
5170 PyThreadState* __tstate = wxPyBeginAllowThreads();
5171 delete arg1;
5172
5173 wxPyEndAllowThreads(__tstate);
5174 if (PyErr_Occurred()) SWIG_fail;
5175 }
5176 resultobj = SWIG_Py_Void();
5177 return resultobj;
5178 fail:
5179 return NULL;
5180 }
5181
5182
5183 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5184 PyObject *resultobj = 0;
5185 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5186 wxRealPoint *arg2 = 0 ;
5187 bool result;
5188 void *argp1 = 0 ;
5189 int res1 = 0 ;
5190 wxRealPoint temp2 ;
5191 PyObject * obj0 = 0 ;
5192 PyObject * obj1 = 0 ;
5193 char * kwnames[] = {
5194 (char *) "self",(char *) "pt", NULL
5195 };
5196
5197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5199 if (!SWIG_IsOK(res1)) {
5200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5201 }
5202 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5203 {
5204 arg2 = &temp2;
5205 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5206 }
5207 {
5208 PyThreadState* __tstate = wxPyBeginAllowThreads();
5209 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 {
5214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5215 }
5216 return resultobj;
5217 fail:
5218 return NULL;
5219 }
5220
5221
5222 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5223 PyObject *resultobj = 0;
5224 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5225 wxRealPoint *arg2 = 0 ;
5226 bool result;
5227 void *argp1 = 0 ;
5228 int res1 = 0 ;
5229 wxRealPoint temp2 ;
5230 PyObject * obj0 = 0 ;
5231 PyObject * obj1 = 0 ;
5232 char * kwnames[] = {
5233 (char *) "self",(char *) "pt", NULL
5234 };
5235
5236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5238 if (!SWIG_IsOK(res1)) {
5239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5240 }
5241 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5242 {
5243 arg2 = &temp2;
5244 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5245 }
5246 {
5247 PyThreadState* __tstate = wxPyBeginAllowThreads();
5248 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
5249 wxPyEndAllowThreads(__tstate);
5250 if (PyErr_Occurred()) SWIG_fail;
5251 }
5252 {
5253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5254 }
5255 return resultobj;
5256 fail:
5257 return NULL;
5258 }
5259
5260
5261 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5262 PyObject *resultobj = 0;
5263 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5264 wxRealPoint *arg2 = 0 ;
5265 wxRealPoint result;
5266 void *argp1 = 0 ;
5267 int res1 = 0 ;
5268 wxRealPoint temp2 ;
5269 PyObject * obj0 = 0 ;
5270 PyObject * obj1 = 0 ;
5271 char * kwnames[] = {
5272 (char *) "self",(char *) "pt", NULL
5273 };
5274
5275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5277 if (!SWIG_IsOK(res1)) {
5278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5279 }
5280 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5281 {
5282 arg2 = &temp2;
5283 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5284 }
5285 {
5286 PyThreadState* __tstate = wxPyBeginAllowThreads();
5287 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5288 wxPyEndAllowThreads(__tstate);
5289 if (PyErr_Occurred()) SWIG_fail;
5290 }
5291 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5292 return resultobj;
5293 fail:
5294 return NULL;
5295 }
5296
5297
5298 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5299 PyObject *resultobj = 0;
5300 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5301 wxRealPoint *arg2 = 0 ;
5302 wxRealPoint result;
5303 void *argp1 = 0 ;
5304 int res1 = 0 ;
5305 wxRealPoint temp2 ;
5306 PyObject * obj0 = 0 ;
5307 PyObject * obj1 = 0 ;
5308 char * kwnames[] = {
5309 (char *) "self",(char *) "pt", NULL
5310 };
5311
5312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5314 if (!SWIG_IsOK(res1)) {
5315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5316 }
5317 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5318 {
5319 arg2 = &temp2;
5320 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5321 }
5322 {
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5325 wxPyEndAllowThreads(__tstate);
5326 if (PyErr_Occurred()) SWIG_fail;
5327 }
5328 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5329 return resultobj;
5330 fail:
5331 return NULL;
5332 }
5333
5334
5335 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5336 PyObject *resultobj = 0;
5337 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5338 double arg2 ;
5339 double arg3 ;
5340 void *argp1 = 0 ;
5341 int res1 = 0 ;
5342 double val2 ;
5343 int ecode2 = 0 ;
5344 double val3 ;
5345 int ecode3 = 0 ;
5346 PyObject * obj0 = 0 ;
5347 PyObject * obj1 = 0 ;
5348 PyObject * obj2 = 0 ;
5349 char * kwnames[] = {
5350 (char *) "self",(char *) "x",(char *) "y", NULL
5351 };
5352
5353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5355 if (!SWIG_IsOK(res1)) {
5356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5357 }
5358 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5359 ecode2 = SWIG_AsVal_double(obj1, &val2);
5360 if (!SWIG_IsOK(ecode2)) {
5361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5362 }
5363 arg2 = static_cast< double >(val2);
5364 ecode3 = SWIG_AsVal_double(obj2, &val3);
5365 if (!SWIG_IsOK(ecode3)) {
5366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5367 }
5368 arg3 = static_cast< double >(val3);
5369 {
5370 PyThreadState* __tstate = wxPyBeginAllowThreads();
5371 wxRealPoint_Set(arg1,arg2,arg3);
5372 wxPyEndAllowThreads(__tstate);
5373 if (PyErr_Occurred()) SWIG_fail;
5374 }
5375 resultobj = SWIG_Py_Void();
5376 return resultobj;
5377 fail:
5378 return NULL;
5379 }
5380
5381
5382 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5383 PyObject *resultobj = 0;
5384 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5385 PyObject *result = 0 ;
5386 void *argp1 = 0 ;
5387 int res1 = 0 ;
5388 PyObject *swig_obj[1] ;
5389
5390 if (!args) SWIG_fail;
5391 swig_obj[0] = args;
5392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5393 if (!SWIG_IsOK(res1)) {
5394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5395 }
5396 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5397 {
5398 PyThreadState* __tstate = wxPyBeginAllowThreads();
5399 result = (PyObject *)wxRealPoint_Get(arg1);
5400 wxPyEndAllowThreads(__tstate);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 resultobj = result;
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5411 PyObject *obj;
5412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5413 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5414 return SWIG_Py_Void();
5415 }
5416
5417 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5418 return SWIG_Python_InitShadowInstance(args);
5419 }
5420
5421 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5422 PyObject *resultobj = 0;
5423 wxPoint *arg1 = (wxPoint *) 0 ;
5424 int arg2 ;
5425 void *argp1 = 0 ;
5426 int res1 = 0 ;
5427 int val2 ;
5428 int ecode2 = 0 ;
5429 PyObject *swig_obj[2] ;
5430
5431 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5433 if (!SWIG_IsOK(res1)) {
5434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5435 }
5436 arg1 = reinterpret_cast< wxPoint * >(argp1);
5437 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5438 if (!SWIG_IsOK(ecode2)) {
5439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5440 }
5441 arg2 = static_cast< int >(val2);
5442 if (arg1) (arg1)->x = arg2;
5443
5444 resultobj = SWIG_Py_Void();
5445 return resultobj;
5446 fail:
5447 return NULL;
5448 }
5449
5450
5451 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5452 PyObject *resultobj = 0;
5453 wxPoint *arg1 = (wxPoint *) 0 ;
5454 int result;
5455 void *argp1 = 0 ;
5456 int res1 = 0 ;
5457 PyObject *swig_obj[1] ;
5458
5459 if (!args) SWIG_fail;
5460 swig_obj[0] = args;
5461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5462 if (!SWIG_IsOK(res1)) {
5463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5464 }
5465 arg1 = reinterpret_cast< wxPoint * >(argp1);
5466 result = (int) ((arg1)->x);
5467 resultobj = SWIG_From_int(static_cast< int >(result));
5468 return resultobj;
5469 fail:
5470 return NULL;
5471 }
5472
5473
5474 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5475 PyObject *resultobj = 0;
5476 wxPoint *arg1 = (wxPoint *) 0 ;
5477 int arg2 ;
5478 void *argp1 = 0 ;
5479 int res1 = 0 ;
5480 int val2 ;
5481 int ecode2 = 0 ;
5482 PyObject *swig_obj[2] ;
5483
5484 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5486 if (!SWIG_IsOK(res1)) {
5487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5488 }
5489 arg1 = reinterpret_cast< wxPoint * >(argp1);
5490 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5491 if (!SWIG_IsOK(ecode2)) {
5492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5493 }
5494 arg2 = static_cast< int >(val2);
5495 if (arg1) (arg1)->y = arg2;
5496
5497 resultobj = SWIG_Py_Void();
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5505 PyObject *resultobj = 0;
5506 wxPoint *arg1 = (wxPoint *) 0 ;
5507 int result;
5508 void *argp1 = 0 ;
5509 int res1 = 0 ;
5510 PyObject *swig_obj[1] ;
5511
5512 if (!args) SWIG_fail;
5513 swig_obj[0] = args;
5514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5515 if (!SWIG_IsOK(res1)) {
5516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5517 }
5518 arg1 = reinterpret_cast< wxPoint * >(argp1);
5519 result = (int) ((arg1)->y);
5520 resultobj = SWIG_From_int(static_cast< int >(result));
5521 return resultobj;
5522 fail:
5523 return NULL;
5524 }
5525
5526
5527 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5528 PyObject *resultobj = 0;
5529 int arg1 = (int) 0 ;
5530 int arg2 = (int) 0 ;
5531 wxPoint *result = 0 ;
5532 int val1 ;
5533 int ecode1 = 0 ;
5534 int val2 ;
5535 int ecode2 = 0 ;
5536 PyObject * obj0 = 0 ;
5537 PyObject * obj1 = 0 ;
5538 char * kwnames[] = {
5539 (char *) "x",(char *) "y", NULL
5540 };
5541
5542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5543 if (obj0) {
5544 ecode1 = SWIG_AsVal_int(obj0, &val1);
5545 if (!SWIG_IsOK(ecode1)) {
5546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5547 }
5548 arg1 = static_cast< int >(val1);
5549 }
5550 if (obj1) {
5551 ecode2 = SWIG_AsVal_int(obj1, &val2);
5552 if (!SWIG_IsOK(ecode2)) {
5553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5554 }
5555 arg2 = static_cast< int >(val2);
5556 }
5557 {
5558 PyThreadState* __tstate = wxPyBeginAllowThreads();
5559 result = (wxPoint *)new wxPoint(arg1,arg2);
5560 wxPyEndAllowThreads(__tstate);
5561 if (PyErr_Occurred()) SWIG_fail;
5562 }
5563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5564 return resultobj;
5565 fail:
5566 return NULL;
5567 }
5568
5569
5570 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5571 PyObject *resultobj = 0;
5572 wxPoint *arg1 = (wxPoint *) 0 ;
5573 void *argp1 = 0 ;
5574 int res1 = 0 ;
5575 PyObject *swig_obj[1] ;
5576
5577 if (!args) SWIG_fail;
5578 swig_obj[0] = args;
5579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5580 if (!SWIG_IsOK(res1)) {
5581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5582 }
5583 arg1 = reinterpret_cast< wxPoint * >(argp1);
5584 {
5585 PyThreadState* __tstate = wxPyBeginAllowThreads();
5586 delete arg1;
5587
5588 wxPyEndAllowThreads(__tstate);
5589 if (PyErr_Occurred()) SWIG_fail;
5590 }
5591 resultobj = SWIG_Py_Void();
5592 return resultobj;
5593 fail:
5594 return NULL;
5595 }
5596
5597
5598 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5599 PyObject *resultobj = 0;
5600 wxPoint *arg1 = (wxPoint *) 0 ;
5601 wxPoint *arg2 = 0 ;
5602 bool result;
5603 void *argp1 = 0 ;
5604 int res1 = 0 ;
5605 wxPoint temp2 ;
5606 PyObject * obj0 = 0 ;
5607 PyObject * obj1 = 0 ;
5608 char * kwnames[] = {
5609 (char *) "self",(char *) "pt", NULL
5610 };
5611
5612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5614 if (!SWIG_IsOK(res1)) {
5615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5616 }
5617 arg1 = reinterpret_cast< wxPoint * >(argp1);
5618 {
5619 arg2 = &temp2;
5620 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5621 }
5622 {
5623 PyThreadState* __tstate = wxPyBeginAllowThreads();
5624 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
5625 wxPyEndAllowThreads(__tstate);
5626 if (PyErr_Occurred()) SWIG_fail;
5627 }
5628 {
5629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5630 }
5631 return resultobj;
5632 fail:
5633 return NULL;
5634 }
5635
5636
5637 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5638 PyObject *resultobj = 0;
5639 wxPoint *arg1 = (wxPoint *) 0 ;
5640 wxPoint *arg2 = 0 ;
5641 bool result;
5642 void *argp1 = 0 ;
5643 int res1 = 0 ;
5644 wxPoint temp2 ;
5645 PyObject * obj0 = 0 ;
5646 PyObject * obj1 = 0 ;
5647 char * kwnames[] = {
5648 (char *) "self",(char *) "pt", NULL
5649 };
5650
5651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5653 if (!SWIG_IsOK(res1)) {
5654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5655 }
5656 arg1 = reinterpret_cast< wxPoint * >(argp1);
5657 {
5658 arg2 = &temp2;
5659 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5660 }
5661 {
5662 PyThreadState* __tstate = wxPyBeginAllowThreads();
5663 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
5664 wxPyEndAllowThreads(__tstate);
5665 if (PyErr_Occurred()) SWIG_fail;
5666 }
5667 {
5668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5669 }
5670 return resultobj;
5671 fail:
5672 return NULL;
5673 }
5674
5675
5676 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5677 PyObject *resultobj = 0;
5678 wxPoint *arg1 = (wxPoint *) 0 ;
5679 wxPoint *arg2 = 0 ;
5680 wxPoint result;
5681 void *argp1 = 0 ;
5682 int res1 = 0 ;
5683 wxPoint temp2 ;
5684 PyObject * obj0 = 0 ;
5685 PyObject * obj1 = 0 ;
5686 char * kwnames[] = {
5687 (char *) "self",(char *) "pt", NULL
5688 };
5689
5690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5692 if (!SWIG_IsOK(res1)) {
5693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5694 }
5695 arg1 = reinterpret_cast< wxPoint * >(argp1);
5696 {
5697 arg2 = &temp2;
5698 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5699 }
5700 {
5701 PyThreadState* __tstate = wxPyBeginAllowThreads();
5702 result = (arg1)->operator +((wxPoint const &)*arg2);
5703 wxPyEndAllowThreads(__tstate);
5704 if (PyErr_Occurred()) SWIG_fail;
5705 }
5706 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5707 return resultobj;
5708 fail:
5709 return NULL;
5710 }
5711
5712
5713 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5714 PyObject *resultobj = 0;
5715 wxPoint *arg1 = (wxPoint *) 0 ;
5716 wxPoint *arg2 = 0 ;
5717 wxPoint result;
5718 void *argp1 = 0 ;
5719 int res1 = 0 ;
5720 wxPoint temp2 ;
5721 PyObject * obj0 = 0 ;
5722 PyObject * obj1 = 0 ;
5723 char * kwnames[] = {
5724 (char *) "self",(char *) "pt", NULL
5725 };
5726
5727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5729 if (!SWIG_IsOK(res1)) {
5730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5731 }
5732 arg1 = reinterpret_cast< wxPoint * >(argp1);
5733 {
5734 arg2 = &temp2;
5735 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5736 }
5737 {
5738 PyThreadState* __tstate = wxPyBeginAllowThreads();
5739 result = (arg1)->operator -((wxPoint const &)*arg2);
5740 wxPyEndAllowThreads(__tstate);
5741 if (PyErr_Occurred()) SWIG_fail;
5742 }
5743 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5744 return resultobj;
5745 fail:
5746 return NULL;
5747 }
5748
5749
5750 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5751 PyObject *resultobj = 0;
5752 wxPoint *arg1 = (wxPoint *) 0 ;
5753 wxPoint *arg2 = 0 ;
5754 wxPoint *result = 0 ;
5755 void *argp1 = 0 ;
5756 int res1 = 0 ;
5757 wxPoint temp2 ;
5758 PyObject * obj0 = 0 ;
5759 PyObject * obj1 = 0 ;
5760 char * kwnames[] = {
5761 (char *) "self",(char *) "pt", NULL
5762 };
5763
5764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5766 if (!SWIG_IsOK(res1)) {
5767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5768 }
5769 arg1 = reinterpret_cast< wxPoint * >(argp1);
5770 {
5771 arg2 = &temp2;
5772 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5773 }
5774 {
5775 PyThreadState* __tstate = wxPyBeginAllowThreads();
5776 {
5777 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5778 result = (wxPoint *) &_result_ref;
5779 }
5780 wxPyEndAllowThreads(__tstate);
5781 if (PyErr_Occurred()) SWIG_fail;
5782 }
5783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5784 return resultobj;
5785 fail:
5786 return NULL;
5787 }
5788
5789
5790 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5791 PyObject *resultobj = 0;
5792 wxPoint *arg1 = (wxPoint *) 0 ;
5793 wxPoint *arg2 = 0 ;
5794 wxPoint *result = 0 ;
5795 void *argp1 = 0 ;
5796 int res1 = 0 ;
5797 wxPoint temp2 ;
5798 PyObject * obj0 = 0 ;
5799 PyObject * obj1 = 0 ;
5800 char * kwnames[] = {
5801 (char *) "self",(char *) "pt", NULL
5802 };
5803
5804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5806 if (!SWIG_IsOK(res1)) {
5807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5808 }
5809 arg1 = reinterpret_cast< wxPoint * >(argp1);
5810 {
5811 arg2 = &temp2;
5812 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5813 }
5814 {
5815 PyThreadState* __tstate = wxPyBeginAllowThreads();
5816 {
5817 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5818 result = (wxPoint *) &_result_ref;
5819 }
5820 wxPyEndAllowThreads(__tstate);
5821 if (PyErr_Occurred()) SWIG_fail;
5822 }
5823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5824 return resultobj;
5825 fail:
5826 return NULL;
5827 }
5828
5829
5830 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5831 PyObject *resultobj = 0;
5832 wxPoint *arg1 = (wxPoint *) 0 ;
5833 long arg2 ;
5834 long arg3 ;
5835 void *argp1 = 0 ;
5836 int res1 = 0 ;
5837 long val2 ;
5838 int ecode2 = 0 ;
5839 long val3 ;
5840 int ecode3 = 0 ;
5841 PyObject * obj0 = 0 ;
5842 PyObject * obj1 = 0 ;
5843 PyObject * obj2 = 0 ;
5844 char * kwnames[] = {
5845 (char *) "self",(char *) "x",(char *) "y", NULL
5846 };
5847
5848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5850 if (!SWIG_IsOK(res1)) {
5851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5852 }
5853 arg1 = reinterpret_cast< wxPoint * >(argp1);
5854 ecode2 = SWIG_AsVal_long(obj1, &val2);
5855 if (!SWIG_IsOK(ecode2)) {
5856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5857 }
5858 arg2 = static_cast< long >(val2);
5859 ecode3 = SWIG_AsVal_long(obj2, &val3);
5860 if (!SWIG_IsOK(ecode3)) {
5861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5862 }
5863 arg3 = static_cast< long >(val3);
5864 {
5865 PyThreadState* __tstate = wxPyBeginAllowThreads();
5866 wxPoint_Set(arg1,arg2,arg3);
5867 wxPyEndAllowThreads(__tstate);
5868 if (PyErr_Occurred()) SWIG_fail;
5869 }
5870 resultobj = SWIG_Py_Void();
5871 return resultobj;
5872 fail:
5873 return NULL;
5874 }
5875
5876
5877 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5878 PyObject *resultobj = 0;
5879 wxPoint *arg1 = (wxPoint *) 0 ;
5880 PyObject *result = 0 ;
5881 void *argp1 = 0 ;
5882 int res1 = 0 ;
5883 PyObject *swig_obj[1] ;
5884
5885 if (!args) SWIG_fail;
5886 swig_obj[0] = args;
5887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5888 if (!SWIG_IsOK(res1)) {
5889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5890 }
5891 arg1 = reinterpret_cast< wxPoint * >(argp1);
5892 {
5893 PyThreadState* __tstate = wxPyBeginAllowThreads();
5894 result = (PyObject *)wxPoint_Get(arg1);
5895 wxPyEndAllowThreads(__tstate);
5896 if (PyErr_Occurred()) SWIG_fail;
5897 }
5898 resultobj = result;
5899 return resultobj;
5900 fail:
5901 return NULL;
5902 }
5903
5904
5905 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5906 PyObject *obj;
5907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5908 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5909 return SWIG_Py_Void();
5910 }
5911
5912 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5913 return SWIG_Python_InitShadowInstance(args);
5914 }
5915
5916 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5917 PyObject *resultobj = 0;
5918 int arg1 = (int) 0 ;
5919 int arg2 = (int) 0 ;
5920 int arg3 = (int) 0 ;
5921 int arg4 = (int) 0 ;
5922 wxRect *result = 0 ;
5923 int val1 ;
5924 int ecode1 = 0 ;
5925 int val2 ;
5926 int ecode2 = 0 ;
5927 int val3 ;
5928 int ecode3 = 0 ;
5929 int val4 ;
5930 int ecode4 = 0 ;
5931 PyObject * obj0 = 0 ;
5932 PyObject * obj1 = 0 ;
5933 PyObject * obj2 = 0 ;
5934 PyObject * obj3 = 0 ;
5935 char * kwnames[] = {
5936 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
5937 };
5938
5939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5940 if (obj0) {
5941 ecode1 = SWIG_AsVal_int(obj0, &val1);
5942 if (!SWIG_IsOK(ecode1)) {
5943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
5944 }
5945 arg1 = static_cast< int >(val1);
5946 }
5947 if (obj1) {
5948 ecode2 = SWIG_AsVal_int(obj1, &val2);
5949 if (!SWIG_IsOK(ecode2)) {
5950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
5951 }
5952 arg2 = static_cast< int >(val2);
5953 }
5954 if (obj2) {
5955 ecode3 = SWIG_AsVal_int(obj2, &val3);
5956 if (!SWIG_IsOK(ecode3)) {
5957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
5958 }
5959 arg3 = static_cast< int >(val3);
5960 }
5961 if (obj3) {
5962 ecode4 = SWIG_AsVal_int(obj3, &val4);
5963 if (!SWIG_IsOK(ecode4)) {
5964 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
5965 }
5966 arg4 = static_cast< int >(val4);
5967 }
5968 {
5969 PyThreadState* __tstate = wxPyBeginAllowThreads();
5970 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
5971 wxPyEndAllowThreads(__tstate);
5972 if (PyErr_Occurred()) SWIG_fail;
5973 }
5974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
5975 return resultobj;
5976 fail:
5977 return NULL;
5978 }
5979
5980
5981 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5982 PyObject *resultobj = 0;
5983 wxPoint *arg1 = 0 ;
5984 wxPoint *arg2 = 0 ;
5985 wxRect *result = 0 ;
5986 wxPoint temp1 ;
5987 wxPoint temp2 ;
5988 PyObject * obj0 = 0 ;
5989 PyObject * obj1 = 0 ;
5990 char * kwnames[] = {
5991 (char *) "topLeft",(char *) "bottomRight", NULL
5992 };
5993
5994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
5995 {
5996 arg1 = &temp1;
5997 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5998 }
5999 {
6000 arg2 = &temp2;
6001 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6002 }
6003 {
6004 PyThreadState* __tstate = wxPyBeginAllowThreads();
6005 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6006 wxPyEndAllowThreads(__tstate);
6007 if (PyErr_Occurred()) SWIG_fail;
6008 }
6009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6010 return resultobj;
6011 fail:
6012 return NULL;
6013 }
6014
6015
6016 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6017 PyObject *resultobj = 0;
6018 wxPoint *arg1 = 0 ;
6019 wxSize *arg2 = 0 ;
6020 wxRect *result = 0 ;
6021 wxPoint temp1 ;
6022 wxSize temp2 ;
6023 PyObject * obj0 = 0 ;
6024 PyObject * obj1 = 0 ;
6025 char * kwnames[] = {
6026 (char *) "pos",(char *) "size", NULL
6027 };
6028
6029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6030 {
6031 arg1 = &temp1;
6032 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6033 }
6034 {
6035 arg2 = &temp2;
6036 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6037 }
6038 {
6039 PyThreadState* __tstate = wxPyBeginAllowThreads();
6040 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6041 wxPyEndAllowThreads(__tstate);
6042 if (PyErr_Occurred()) SWIG_fail;
6043 }
6044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6045 return resultobj;
6046 fail:
6047 return NULL;
6048 }
6049
6050
6051 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6052 PyObject *resultobj = 0;
6053 wxSize *arg1 = 0 ;
6054 wxRect *result = 0 ;
6055 wxSize temp1 ;
6056 PyObject * obj0 = 0 ;
6057 char * kwnames[] = {
6058 (char *) "size", NULL
6059 };
6060
6061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6062 {
6063 arg1 = &temp1;
6064 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6065 }
6066 {
6067 PyThreadState* __tstate = wxPyBeginAllowThreads();
6068 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6069 wxPyEndAllowThreads(__tstate);
6070 if (PyErr_Occurred()) SWIG_fail;
6071 }
6072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6073 return resultobj;
6074 fail:
6075 return NULL;
6076 }
6077
6078
6079 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6080 PyObject *resultobj = 0;
6081 wxRect *arg1 = (wxRect *) 0 ;
6082 void *argp1 = 0 ;
6083 int res1 = 0 ;
6084 PyObject *swig_obj[1] ;
6085
6086 if (!args) SWIG_fail;
6087 swig_obj[0] = args;
6088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6089 if (!SWIG_IsOK(res1)) {
6090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6091 }
6092 arg1 = reinterpret_cast< wxRect * >(argp1);
6093 {
6094 PyThreadState* __tstate = wxPyBeginAllowThreads();
6095 delete arg1;
6096
6097 wxPyEndAllowThreads(__tstate);
6098 if (PyErr_Occurred()) SWIG_fail;
6099 }
6100 resultobj = SWIG_Py_Void();
6101 return resultobj;
6102 fail:
6103 return NULL;
6104 }
6105
6106
6107 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6108 PyObject *resultobj = 0;
6109 wxRect *arg1 = (wxRect *) 0 ;
6110 int result;
6111 void *argp1 = 0 ;
6112 int res1 = 0 ;
6113 PyObject *swig_obj[1] ;
6114
6115 if (!args) SWIG_fail;
6116 swig_obj[0] = args;
6117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6118 if (!SWIG_IsOK(res1)) {
6119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6120 }
6121 arg1 = reinterpret_cast< wxRect * >(argp1);
6122 {
6123 PyThreadState* __tstate = wxPyBeginAllowThreads();
6124 result = (int)((wxRect const *)arg1)->GetX();
6125 wxPyEndAllowThreads(__tstate);
6126 if (PyErr_Occurred()) SWIG_fail;
6127 }
6128 resultobj = SWIG_From_int(static_cast< int >(result));
6129 return resultobj;
6130 fail:
6131 return NULL;
6132 }
6133
6134
6135 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6136 PyObject *resultobj = 0;
6137 wxRect *arg1 = (wxRect *) 0 ;
6138 int arg2 ;
6139 void *argp1 = 0 ;
6140 int res1 = 0 ;
6141 int val2 ;
6142 int ecode2 = 0 ;
6143 PyObject * obj0 = 0 ;
6144 PyObject * obj1 = 0 ;
6145 char * kwnames[] = {
6146 (char *) "self",(char *) "x", NULL
6147 };
6148
6149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6151 if (!SWIG_IsOK(res1)) {
6152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6153 }
6154 arg1 = reinterpret_cast< wxRect * >(argp1);
6155 ecode2 = SWIG_AsVal_int(obj1, &val2);
6156 if (!SWIG_IsOK(ecode2)) {
6157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6158 }
6159 arg2 = static_cast< int >(val2);
6160 {
6161 PyThreadState* __tstate = wxPyBeginAllowThreads();
6162 (arg1)->SetX(arg2);
6163 wxPyEndAllowThreads(__tstate);
6164 if (PyErr_Occurred()) SWIG_fail;
6165 }
6166 resultobj = SWIG_Py_Void();
6167 return resultobj;
6168 fail:
6169 return NULL;
6170 }
6171
6172
6173 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6174 PyObject *resultobj = 0;
6175 wxRect *arg1 = (wxRect *) 0 ;
6176 int result;
6177 void *argp1 = 0 ;
6178 int res1 = 0 ;
6179 PyObject *swig_obj[1] ;
6180
6181 if (!args) SWIG_fail;
6182 swig_obj[0] = args;
6183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6184 if (!SWIG_IsOK(res1)) {
6185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6186 }
6187 arg1 = reinterpret_cast< wxRect * >(argp1);
6188 {
6189 PyThreadState* __tstate = wxPyBeginAllowThreads();
6190 result = (int)(arg1)->GetY();
6191 wxPyEndAllowThreads(__tstate);
6192 if (PyErr_Occurred()) SWIG_fail;
6193 }
6194 resultobj = SWIG_From_int(static_cast< int >(result));
6195 return resultobj;
6196 fail:
6197 return NULL;
6198 }
6199
6200
6201 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6202 PyObject *resultobj = 0;
6203 wxRect *arg1 = (wxRect *) 0 ;
6204 int arg2 ;
6205 void *argp1 = 0 ;
6206 int res1 = 0 ;
6207 int val2 ;
6208 int ecode2 = 0 ;
6209 PyObject * obj0 = 0 ;
6210 PyObject * obj1 = 0 ;
6211 char * kwnames[] = {
6212 (char *) "self",(char *) "y", NULL
6213 };
6214
6215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6217 if (!SWIG_IsOK(res1)) {
6218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6219 }
6220 arg1 = reinterpret_cast< wxRect * >(argp1);
6221 ecode2 = SWIG_AsVal_int(obj1, &val2);
6222 if (!SWIG_IsOK(ecode2)) {
6223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6224 }
6225 arg2 = static_cast< int >(val2);
6226 {
6227 PyThreadState* __tstate = wxPyBeginAllowThreads();
6228 (arg1)->SetY(arg2);
6229 wxPyEndAllowThreads(__tstate);
6230 if (PyErr_Occurred()) SWIG_fail;
6231 }
6232 resultobj = SWIG_Py_Void();
6233 return resultobj;
6234 fail:
6235 return NULL;
6236 }
6237
6238
6239 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6240 PyObject *resultobj = 0;
6241 wxRect *arg1 = (wxRect *) 0 ;
6242 int result;
6243 void *argp1 = 0 ;
6244 int res1 = 0 ;
6245 PyObject *swig_obj[1] ;
6246
6247 if (!args) SWIG_fail;
6248 swig_obj[0] = args;
6249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6250 if (!SWIG_IsOK(res1)) {
6251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6252 }
6253 arg1 = reinterpret_cast< wxRect * >(argp1);
6254 {
6255 PyThreadState* __tstate = wxPyBeginAllowThreads();
6256 result = (int)((wxRect const *)arg1)->GetWidth();
6257 wxPyEndAllowThreads(__tstate);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 resultobj = SWIG_From_int(static_cast< int >(result));
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6268 PyObject *resultobj = 0;
6269 wxRect *arg1 = (wxRect *) 0 ;
6270 int arg2 ;
6271 void *argp1 = 0 ;
6272 int res1 = 0 ;
6273 int val2 ;
6274 int ecode2 = 0 ;
6275 PyObject * obj0 = 0 ;
6276 PyObject * obj1 = 0 ;
6277 char * kwnames[] = {
6278 (char *) "self",(char *) "w", NULL
6279 };
6280
6281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6283 if (!SWIG_IsOK(res1)) {
6284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6285 }
6286 arg1 = reinterpret_cast< wxRect * >(argp1);
6287 ecode2 = SWIG_AsVal_int(obj1, &val2);
6288 if (!SWIG_IsOK(ecode2)) {
6289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6290 }
6291 arg2 = static_cast< int >(val2);
6292 {
6293 PyThreadState* __tstate = wxPyBeginAllowThreads();
6294 (arg1)->SetWidth(arg2);
6295 wxPyEndAllowThreads(__tstate);
6296 if (PyErr_Occurred()) SWIG_fail;
6297 }
6298 resultobj = SWIG_Py_Void();
6299 return resultobj;
6300 fail:
6301 return NULL;
6302 }
6303
6304
6305 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6306 PyObject *resultobj = 0;
6307 wxRect *arg1 = (wxRect *) 0 ;
6308 int result;
6309 void *argp1 = 0 ;
6310 int res1 = 0 ;
6311 PyObject *swig_obj[1] ;
6312
6313 if (!args) SWIG_fail;
6314 swig_obj[0] = args;
6315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6316 if (!SWIG_IsOK(res1)) {
6317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6318 }
6319 arg1 = reinterpret_cast< wxRect * >(argp1);
6320 {
6321 PyThreadState* __tstate = wxPyBeginAllowThreads();
6322 result = (int)((wxRect const *)arg1)->GetHeight();
6323 wxPyEndAllowThreads(__tstate);
6324 if (PyErr_Occurred()) SWIG_fail;
6325 }
6326 resultobj = SWIG_From_int(static_cast< int >(result));
6327 return resultobj;
6328 fail:
6329 return NULL;
6330 }
6331
6332
6333 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6334 PyObject *resultobj = 0;
6335 wxRect *arg1 = (wxRect *) 0 ;
6336 int arg2 ;
6337 void *argp1 = 0 ;
6338 int res1 = 0 ;
6339 int val2 ;
6340 int ecode2 = 0 ;
6341 PyObject * obj0 = 0 ;
6342 PyObject * obj1 = 0 ;
6343 char * kwnames[] = {
6344 (char *) "self",(char *) "h", NULL
6345 };
6346
6347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6349 if (!SWIG_IsOK(res1)) {
6350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6351 }
6352 arg1 = reinterpret_cast< wxRect * >(argp1);
6353 ecode2 = SWIG_AsVal_int(obj1, &val2);
6354 if (!SWIG_IsOK(ecode2)) {
6355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6356 }
6357 arg2 = static_cast< int >(val2);
6358 {
6359 PyThreadState* __tstate = wxPyBeginAllowThreads();
6360 (arg1)->SetHeight(arg2);
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 resultobj = SWIG_Py_Void();
6365 return resultobj;
6366 fail:
6367 return NULL;
6368 }
6369
6370
6371 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6372 PyObject *resultobj = 0;
6373 wxRect *arg1 = (wxRect *) 0 ;
6374 wxPoint result;
6375 void *argp1 = 0 ;
6376 int res1 = 0 ;
6377 PyObject *swig_obj[1] ;
6378
6379 if (!args) SWIG_fail;
6380 swig_obj[0] = args;
6381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6382 if (!SWIG_IsOK(res1)) {
6383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6384 }
6385 arg1 = reinterpret_cast< wxRect * >(argp1);
6386 {
6387 PyThreadState* __tstate = wxPyBeginAllowThreads();
6388 result = ((wxRect const *)arg1)->GetPosition();
6389 wxPyEndAllowThreads(__tstate);
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6400 PyObject *resultobj = 0;
6401 wxRect *arg1 = (wxRect *) 0 ;
6402 wxPoint *arg2 = 0 ;
6403 void *argp1 = 0 ;
6404 int res1 = 0 ;
6405 wxPoint temp2 ;
6406 PyObject * obj0 = 0 ;
6407 PyObject * obj1 = 0 ;
6408 char * kwnames[] = {
6409 (char *) "self",(char *) "p", NULL
6410 };
6411
6412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6414 if (!SWIG_IsOK(res1)) {
6415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6416 }
6417 arg1 = reinterpret_cast< wxRect * >(argp1);
6418 {
6419 arg2 = &temp2;
6420 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6421 }
6422 {
6423 PyThreadState* __tstate = wxPyBeginAllowThreads();
6424 (arg1)->SetPosition((wxPoint const &)*arg2);
6425 wxPyEndAllowThreads(__tstate);
6426 if (PyErr_Occurred()) SWIG_fail;
6427 }
6428 resultobj = SWIG_Py_Void();
6429 return resultobj;
6430 fail:
6431 return NULL;
6432 }
6433
6434
6435 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6436 PyObject *resultobj = 0;
6437 wxRect *arg1 = (wxRect *) 0 ;
6438 wxSize result;
6439 void *argp1 = 0 ;
6440 int res1 = 0 ;
6441 PyObject *swig_obj[1] ;
6442
6443 if (!args) SWIG_fail;
6444 swig_obj[0] = args;
6445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6446 if (!SWIG_IsOK(res1)) {
6447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6448 }
6449 arg1 = reinterpret_cast< wxRect * >(argp1);
6450 {
6451 PyThreadState* __tstate = wxPyBeginAllowThreads();
6452 result = ((wxRect const *)arg1)->GetSize();
6453 wxPyEndAllowThreads(__tstate);
6454 if (PyErr_Occurred()) SWIG_fail;
6455 }
6456 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6457 return resultobj;
6458 fail:
6459 return NULL;
6460 }
6461
6462
6463 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6464 PyObject *resultobj = 0;
6465 wxRect *arg1 = (wxRect *) 0 ;
6466 wxSize *arg2 = 0 ;
6467 void *argp1 = 0 ;
6468 int res1 = 0 ;
6469 wxSize temp2 ;
6470 PyObject * obj0 = 0 ;
6471 PyObject * obj1 = 0 ;
6472 char * kwnames[] = {
6473 (char *) "self",(char *) "s", NULL
6474 };
6475
6476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6478 if (!SWIG_IsOK(res1)) {
6479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6480 }
6481 arg1 = reinterpret_cast< wxRect * >(argp1);
6482 {
6483 arg2 = &temp2;
6484 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6485 }
6486 {
6487 PyThreadState* __tstate = wxPyBeginAllowThreads();
6488 (arg1)->SetSize((wxSize const &)*arg2);
6489 wxPyEndAllowThreads(__tstate);
6490 if (PyErr_Occurred()) SWIG_fail;
6491 }
6492 resultobj = SWIG_Py_Void();
6493 return resultobj;
6494 fail:
6495 return NULL;
6496 }
6497
6498
6499 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6500 PyObject *resultobj = 0;
6501 wxRect *arg1 = (wxRect *) 0 ;
6502 bool result;
6503 void *argp1 = 0 ;
6504 int res1 = 0 ;
6505 PyObject *swig_obj[1] ;
6506
6507 if (!args) SWIG_fail;
6508 swig_obj[0] = args;
6509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6510 if (!SWIG_IsOK(res1)) {
6511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6512 }
6513 arg1 = reinterpret_cast< wxRect * >(argp1);
6514 {
6515 PyThreadState* __tstate = wxPyBeginAllowThreads();
6516 result = (bool)((wxRect const *)arg1)->IsEmpty();
6517 wxPyEndAllowThreads(__tstate);
6518 if (PyErr_Occurred()) SWIG_fail;
6519 }
6520 {
6521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6522 }
6523 return resultobj;
6524 fail:
6525 return NULL;
6526 }
6527
6528
6529 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6530 PyObject *resultobj = 0;
6531 wxRect *arg1 = (wxRect *) 0 ;
6532 wxPoint result;
6533 void *argp1 = 0 ;
6534 int res1 = 0 ;
6535 PyObject *swig_obj[1] ;
6536
6537 if (!args) SWIG_fail;
6538 swig_obj[0] = args;
6539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6540 if (!SWIG_IsOK(res1)) {
6541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6542 }
6543 arg1 = reinterpret_cast< wxRect * >(argp1);
6544 {
6545 PyThreadState* __tstate = wxPyBeginAllowThreads();
6546 result = ((wxRect const *)arg1)->GetTopLeft();
6547 wxPyEndAllowThreads(__tstate);
6548 if (PyErr_Occurred()) SWIG_fail;
6549 }
6550 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6551 return resultobj;
6552 fail:
6553 return NULL;
6554 }
6555
6556
6557 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6558 PyObject *resultobj = 0;
6559 wxRect *arg1 = (wxRect *) 0 ;
6560 wxPoint *arg2 = 0 ;
6561 void *argp1 = 0 ;
6562 int res1 = 0 ;
6563 wxPoint temp2 ;
6564 PyObject * obj0 = 0 ;
6565 PyObject * obj1 = 0 ;
6566 char * kwnames[] = {
6567 (char *) "self",(char *) "p", NULL
6568 };
6569
6570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6572 if (!SWIG_IsOK(res1)) {
6573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6574 }
6575 arg1 = reinterpret_cast< wxRect * >(argp1);
6576 {
6577 arg2 = &temp2;
6578 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6579 }
6580 {
6581 PyThreadState* __tstate = wxPyBeginAllowThreads();
6582 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6583 wxPyEndAllowThreads(__tstate);
6584 if (PyErr_Occurred()) SWIG_fail;
6585 }
6586 resultobj = SWIG_Py_Void();
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6594 PyObject *resultobj = 0;
6595 wxRect *arg1 = (wxRect *) 0 ;
6596 wxPoint result;
6597 void *argp1 = 0 ;
6598 int res1 = 0 ;
6599 PyObject *swig_obj[1] ;
6600
6601 if (!args) SWIG_fail;
6602 swig_obj[0] = args;
6603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6604 if (!SWIG_IsOK(res1)) {
6605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6606 }
6607 arg1 = reinterpret_cast< wxRect * >(argp1);
6608 {
6609 PyThreadState* __tstate = wxPyBeginAllowThreads();
6610 result = ((wxRect const *)arg1)->GetBottomRight();
6611 wxPyEndAllowThreads(__tstate);
6612 if (PyErr_Occurred()) SWIG_fail;
6613 }
6614 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6615 return resultobj;
6616 fail:
6617 return NULL;
6618 }
6619
6620
6621 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6622 PyObject *resultobj = 0;
6623 wxRect *arg1 = (wxRect *) 0 ;
6624 wxPoint *arg2 = 0 ;
6625 void *argp1 = 0 ;
6626 int res1 = 0 ;
6627 wxPoint temp2 ;
6628 PyObject * obj0 = 0 ;
6629 PyObject * obj1 = 0 ;
6630 char * kwnames[] = {
6631 (char *) "self",(char *) "p", NULL
6632 };
6633
6634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6636 if (!SWIG_IsOK(res1)) {
6637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6638 }
6639 arg1 = reinterpret_cast< wxRect * >(argp1);
6640 {
6641 arg2 = &temp2;
6642 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6643 }
6644 {
6645 PyThreadState* __tstate = wxPyBeginAllowThreads();
6646 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6647 wxPyEndAllowThreads(__tstate);
6648 if (PyErr_Occurred()) SWIG_fail;
6649 }
6650 resultobj = SWIG_Py_Void();
6651 return resultobj;
6652 fail:
6653 return NULL;
6654 }
6655
6656
6657 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6658 PyObject *resultobj = 0;
6659 wxRect *arg1 = (wxRect *) 0 ;
6660 int result;
6661 void *argp1 = 0 ;
6662 int res1 = 0 ;
6663 PyObject *swig_obj[1] ;
6664
6665 if (!args) SWIG_fail;
6666 swig_obj[0] = args;
6667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6668 if (!SWIG_IsOK(res1)) {
6669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6670 }
6671 arg1 = reinterpret_cast< wxRect * >(argp1);
6672 {
6673 PyThreadState* __tstate = wxPyBeginAllowThreads();
6674 result = (int)((wxRect const *)arg1)->GetLeft();
6675 wxPyEndAllowThreads(__tstate);
6676 if (PyErr_Occurred()) SWIG_fail;
6677 }
6678 resultobj = SWIG_From_int(static_cast< int >(result));
6679 return resultobj;
6680 fail:
6681 return NULL;
6682 }
6683
6684
6685 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6686 PyObject *resultobj = 0;
6687 wxRect *arg1 = (wxRect *) 0 ;
6688 int result;
6689 void *argp1 = 0 ;
6690 int res1 = 0 ;
6691 PyObject *swig_obj[1] ;
6692
6693 if (!args) SWIG_fail;
6694 swig_obj[0] = args;
6695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6696 if (!SWIG_IsOK(res1)) {
6697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6698 }
6699 arg1 = reinterpret_cast< wxRect * >(argp1);
6700 {
6701 PyThreadState* __tstate = wxPyBeginAllowThreads();
6702 result = (int)((wxRect const *)arg1)->GetTop();
6703 wxPyEndAllowThreads(__tstate);
6704 if (PyErr_Occurred()) SWIG_fail;
6705 }
6706 resultobj = SWIG_From_int(static_cast< int >(result));
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6714 PyObject *resultobj = 0;
6715 wxRect *arg1 = (wxRect *) 0 ;
6716 int result;
6717 void *argp1 = 0 ;
6718 int res1 = 0 ;
6719 PyObject *swig_obj[1] ;
6720
6721 if (!args) SWIG_fail;
6722 swig_obj[0] = args;
6723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6724 if (!SWIG_IsOK(res1)) {
6725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6726 }
6727 arg1 = reinterpret_cast< wxRect * >(argp1);
6728 {
6729 PyThreadState* __tstate = wxPyBeginAllowThreads();
6730 result = (int)((wxRect const *)arg1)->GetBottom();
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 resultobj = SWIG_From_int(static_cast< int >(result));
6735 return resultobj;
6736 fail:
6737 return NULL;
6738 }
6739
6740
6741 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6742 PyObject *resultobj = 0;
6743 wxRect *arg1 = (wxRect *) 0 ;
6744 int result;
6745 void *argp1 = 0 ;
6746 int res1 = 0 ;
6747 PyObject *swig_obj[1] ;
6748
6749 if (!args) SWIG_fail;
6750 swig_obj[0] = args;
6751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6752 if (!SWIG_IsOK(res1)) {
6753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6754 }
6755 arg1 = reinterpret_cast< wxRect * >(argp1);
6756 {
6757 PyThreadState* __tstate = wxPyBeginAllowThreads();
6758 result = (int)((wxRect const *)arg1)->GetRight();
6759 wxPyEndAllowThreads(__tstate);
6760 if (PyErr_Occurred()) SWIG_fail;
6761 }
6762 resultobj = SWIG_From_int(static_cast< int >(result));
6763 return resultobj;
6764 fail:
6765 return NULL;
6766 }
6767
6768
6769 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6770 PyObject *resultobj = 0;
6771 wxRect *arg1 = (wxRect *) 0 ;
6772 int arg2 ;
6773 void *argp1 = 0 ;
6774 int res1 = 0 ;
6775 int val2 ;
6776 int ecode2 = 0 ;
6777 PyObject * obj0 = 0 ;
6778 PyObject * obj1 = 0 ;
6779 char * kwnames[] = {
6780 (char *) "self",(char *) "left", NULL
6781 };
6782
6783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6785 if (!SWIG_IsOK(res1)) {
6786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6787 }
6788 arg1 = reinterpret_cast< wxRect * >(argp1);
6789 ecode2 = SWIG_AsVal_int(obj1, &val2);
6790 if (!SWIG_IsOK(ecode2)) {
6791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6792 }
6793 arg2 = static_cast< int >(val2);
6794 {
6795 PyThreadState* __tstate = wxPyBeginAllowThreads();
6796 (arg1)->SetLeft(arg2);
6797 wxPyEndAllowThreads(__tstate);
6798 if (PyErr_Occurred()) SWIG_fail;
6799 }
6800 resultobj = SWIG_Py_Void();
6801 return resultobj;
6802 fail:
6803 return NULL;
6804 }
6805
6806
6807 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6808 PyObject *resultobj = 0;
6809 wxRect *arg1 = (wxRect *) 0 ;
6810 int arg2 ;
6811 void *argp1 = 0 ;
6812 int res1 = 0 ;
6813 int val2 ;
6814 int ecode2 = 0 ;
6815 PyObject * obj0 = 0 ;
6816 PyObject * obj1 = 0 ;
6817 char * kwnames[] = {
6818 (char *) "self",(char *) "right", NULL
6819 };
6820
6821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6823 if (!SWIG_IsOK(res1)) {
6824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6825 }
6826 arg1 = reinterpret_cast< wxRect * >(argp1);
6827 ecode2 = SWIG_AsVal_int(obj1, &val2);
6828 if (!SWIG_IsOK(ecode2)) {
6829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6830 }
6831 arg2 = static_cast< int >(val2);
6832 {
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 (arg1)->SetRight(arg2);
6835 wxPyEndAllowThreads(__tstate);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 resultobj = SWIG_Py_Void();
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 SWIGINTERN PyObject *_wrap_Rect_SetTop(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 *) "top", NULL
6857 };
6858
6859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",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_SetTop" "', 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_SetTop" "', expected argument " "2"" of type '" "int""'");
6868 }
6869 arg2 = static_cast< int >(val2);
6870 {
6871 PyThreadState* __tstate = wxPyBeginAllowThreads();
6872 (arg1)->SetTop(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_SetBottom(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 *) "bottom", NULL
6895 };
6896
6897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",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_SetBottom" "', 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_SetBottom" "', expected argument " "2"" of type '" "int""'");
6906 }
6907 arg2 = static_cast< int >(val2);
6908 {
6909 PyThreadState* __tstate = wxPyBeginAllowThreads();
6910 (arg1)->SetBottom(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_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6922 PyObject *resultobj = 0;
6923 wxRect *arg1 = (wxRect *) 0 ;
6924 int arg2 ;
6925 int arg3 ;
6926 wxRect *result = 0 ;
6927 void *argp1 = 0 ;
6928 int res1 = 0 ;
6929 int val2 ;
6930 int ecode2 = 0 ;
6931 int val3 ;
6932 int ecode3 = 0 ;
6933 PyObject * obj0 = 0 ;
6934 PyObject * obj1 = 0 ;
6935 PyObject * obj2 = 0 ;
6936 char * kwnames[] = {
6937 (char *) "self",(char *) "dx",(char *) "dy", NULL
6938 };
6939
6940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6942 if (!SWIG_IsOK(res1)) {
6943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
6944 }
6945 arg1 = reinterpret_cast< wxRect * >(argp1);
6946 ecode2 = SWIG_AsVal_int(obj1, &val2);
6947 if (!SWIG_IsOK(ecode2)) {
6948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
6949 }
6950 arg2 = static_cast< int >(val2);
6951 ecode3 = SWIG_AsVal_int(obj2, &val3);
6952 if (!SWIG_IsOK(ecode3)) {
6953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
6954 }
6955 arg3 = static_cast< int >(val3);
6956 {
6957 PyThreadState* __tstate = wxPyBeginAllowThreads();
6958 {
6959 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
6960 result = (wxRect *) &_result_ref;
6961 }
6962 wxPyEndAllowThreads(__tstate);
6963 if (PyErr_Occurred()) SWIG_fail;
6964 }
6965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
6966 return resultobj;
6967 fail:
6968 return NULL;
6969 }
6970
6971
6972 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6973 PyObject *resultobj = 0;
6974 wxRect *arg1 = (wxRect *) 0 ;
6975 int arg2 ;
6976 int arg3 ;
6977 wxRect *result = 0 ;
6978 void *argp1 = 0 ;
6979 int res1 = 0 ;
6980 int val2 ;
6981 int ecode2 = 0 ;
6982 int val3 ;
6983 int ecode3 = 0 ;
6984 PyObject * obj0 = 0 ;
6985 PyObject * obj1 = 0 ;
6986 PyObject * obj2 = 0 ;
6987 char * kwnames[] = {
6988 (char *) "self",(char *) "dx",(char *) "dy", NULL
6989 };
6990
6991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6993 if (!SWIG_IsOK(res1)) {
6994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
6995 }
6996 arg1 = reinterpret_cast< wxRect * >(argp1);
6997 ecode2 = SWIG_AsVal_int(obj1, &val2);
6998 if (!SWIG_IsOK(ecode2)) {
6999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7000 }
7001 arg2 = static_cast< int >(val2);
7002 ecode3 = SWIG_AsVal_int(obj2, &val3);
7003 if (!SWIG_IsOK(ecode3)) {
7004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7005 }
7006 arg3 = static_cast< int >(val3);
7007 {
7008 PyThreadState* __tstate = wxPyBeginAllowThreads();
7009 {
7010 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7011 result = (wxRect *) &_result_ref;
7012 }
7013 wxPyEndAllowThreads(__tstate);
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7017 return resultobj;
7018 fail:
7019 return NULL;
7020 }
7021
7022
7023 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7024 PyObject *resultobj = 0;
7025 wxRect *arg1 = (wxRect *) 0 ;
7026 int arg2 ;
7027 int arg3 ;
7028 void *argp1 = 0 ;
7029 int res1 = 0 ;
7030 int val2 ;
7031 int ecode2 = 0 ;
7032 int val3 ;
7033 int ecode3 = 0 ;
7034 PyObject * obj0 = 0 ;
7035 PyObject * obj1 = 0 ;
7036 PyObject * obj2 = 0 ;
7037 char * kwnames[] = {
7038 (char *) "self",(char *) "dx",(char *) "dy", NULL
7039 };
7040
7041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7043 if (!SWIG_IsOK(res1)) {
7044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7045 }
7046 arg1 = reinterpret_cast< wxRect * >(argp1);
7047 ecode2 = SWIG_AsVal_int(obj1, &val2);
7048 if (!SWIG_IsOK(ecode2)) {
7049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7050 }
7051 arg2 = static_cast< int >(val2);
7052 ecode3 = SWIG_AsVal_int(obj2, &val3);
7053 if (!SWIG_IsOK(ecode3)) {
7054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7055 }
7056 arg3 = static_cast< int >(val3);
7057 {
7058 PyThreadState* __tstate = wxPyBeginAllowThreads();
7059 (arg1)->Offset(arg2,arg3);
7060 wxPyEndAllowThreads(__tstate);
7061 if (PyErr_Occurred()) SWIG_fail;
7062 }
7063 resultobj = SWIG_Py_Void();
7064 return resultobj;
7065 fail:
7066 return NULL;
7067 }
7068
7069
7070 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7071 PyObject *resultobj = 0;
7072 wxRect *arg1 = (wxRect *) 0 ;
7073 wxPoint *arg2 = 0 ;
7074 void *argp1 = 0 ;
7075 int res1 = 0 ;
7076 wxPoint temp2 ;
7077 PyObject * obj0 = 0 ;
7078 PyObject * obj1 = 0 ;
7079 char * kwnames[] = {
7080 (char *) "self",(char *) "pt", NULL
7081 };
7082
7083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7085 if (!SWIG_IsOK(res1)) {
7086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7087 }
7088 arg1 = reinterpret_cast< wxRect * >(argp1);
7089 {
7090 arg2 = &temp2;
7091 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7092 }
7093 {
7094 PyThreadState* __tstate = wxPyBeginAllowThreads();
7095 (arg1)->Offset((wxPoint const &)*arg2);
7096 wxPyEndAllowThreads(__tstate);
7097 if (PyErr_Occurred()) SWIG_fail;
7098 }
7099 resultobj = SWIG_Py_Void();
7100 return resultobj;
7101 fail:
7102 return NULL;
7103 }
7104
7105
7106 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7107 PyObject *resultobj = 0;
7108 wxRect *arg1 = (wxRect *) 0 ;
7109 wxRect *arg2 = 0 ;
7110 wxRect result;
7111 void *argp1 = 0 ;
7112 int res1 = 0 ;
7113 wxRect temp2 ;
7114 PyObject * obj0 = 0 ;
7115 PyObject * obj1 = 0 ;
7116 char * kwnames[] = {
7117 (char *) "self",(char *) "rect", NULL
7118 };
7119
7120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7122 if (!SWIG_IsOK(res1)) {
7123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7124 }
7125 arg1 = reinterpret_cast< wxRect * >(argp1);
7126 {
7127 arg2 = &temp2;
7128 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7129 }
7130 {
7131 PyThreadState* __tstate = wxPyBeginAllowThreads();
7132 result = (arg1)->Intersect((wxRect const &)*arg2);
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7137 return resultobj;
7138 fail:
7139 return NULL;
7140 }
7141
7142
7143 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7144 PyObject *resultobj = 0;
7145 wxRect *arg1 = (wxRect *) 0 ;
7146 wxRect *arg2 = 0 ;
7147 wxRect result;
7148 void *argp1 = 0 ;
7149 int res1 = 0 ;
7150 wxRect temp2 ;
7151 PyObject * obj0 = 0 ;
7152 PyObject * obj1 = 0 ;
7153 char * kwnames[] = {
7154 (char *) "self",(char *) "rect", NULL
7155 };
7156
7157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7159 if (!SWIG_IsOK(res1)) {
7160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7161 }
7162 arg1 = reinterpret_cast< wxRect * >(argp1);
7163 {
7164 arg2 = &temp2;
7165 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7166 }
7167 {
7168 PyThreadState* __tstate = wxPyBeginAllowThreads();
7169 result = (arg1)->Union((wxRect const &)*arg2);
7170 wxPyEndAllowThreads(__tstate);
7171 if (PyErr_Occurred()) SWIG_fail;
7172 }
7173 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7174 return resultobj;
7175 fail:
7176 return NULL;
7177 }
7178
7179
7180 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7181 PyObject *resultobj = 0;
7182 wxRect *arg1 = (wxRect *) 0 ;
7183 wxRect *arg2 = 0 ;
7184 wxRect result;
7185 void *argp1 = 0 ;
7186 int res1 = 0 ;
7187 wxRect temp2 ;
7188 PyObject * obj0 = 0 ;
7189 PyObject * obj1 = 0 ;
7190 char * kwnames[] = {
7191 (char *) "self",(char *) "rect", NULL
7192 };
7193
7194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7196 if (!SWIG_IsOK(res1)) {
7197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7198 }
7199 arg1 = reinterpret_cast< wxRect * >(argp1);
7200 {
7201 arg2 = &temp2;
7202 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7203 }
7204 {
7205 PyThreadState* __tstate = wxPyBeginAllowThreads();
7206 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7207 wxPyEndAllowThreads(__tstate);
7208 if (PyErr_Occurred()) SWIG_fail;
7209 }
7210 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7211 return resultobj;
7212 fail:
7213 return NULL;
7214 }
7215
7216
7217 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7218 PyObject *resultobj = 0;
7219 wxRect *arg1 = (wxRect *) 0 ;
7220 wxRect *arg2 = 0 ;
7221 wxRect *result = 0 ;
7222 void *argp1 = 0 ;
7223 int res1 = 0 ;
7224 wxRect temp2 ;
7225 PyObject * obj0 = 0 ;
7226 PyObject * obj1 = 0 ;
7227 char * kwnames[] = {
7228 (char *) "self",(char *) "rect", NULL
7229 };
7230
7231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7233 if (!SWIG_IsOK(res1)) {
7234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7235 }
7236 arg1 = reinterpret_cast< wxRect * >(argp1);
7237 {
7238 arg2 = &temp2;
7239 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7240 }
7241 {
7242 PyThreadState* __tstate = wxPyBeginAllowThreads();
7243 {
7244 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7245 result = (wxRect *) &_result_ref;
7246 }
7247 wxPyEndAllowThreads(__tstate);
7248 if (PyErr_Occurred()) SWIG_fail;
7249 }
7250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7251 return resultobj;
7252 fail:
7253 return NULL;
7254 }
7255
7256
7257 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7258 PyObject *resultobj = 0;
7259 wxRect *arg1 = (wxRect *) 0 ;
7260 wxRect *arg2 = 0 ;
7261 bool result;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 wxRect temp2 ;
7265 PyObject * obj0 = 0 ;
7266 PyObject * obj1 = 0 ;
7267 char * kwnames[] = {
7268 (char *) "self",(char *) "rect", NULL
7269 };
7270
7271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7273 if (!SWIG_IsOK(res1)) {
7274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect const *""'");
7275 }
7276 arg1 = reinterpret_cast< wxRect * >(argp1);
7277 {
7278 arg2 = &temp2;
7279 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7280 }
7281 {
7282 PyThreadState* __tstate = wxPyBeginAllowThreads();
7283 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
7284 wxPyEndAllowThreads(__tstate);
7285 if (PyErr_Occurred()) SWIG_fail;
7286 }
7287 {
7288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7289 }
7290 return resultobj;
7291 fail:
7292 return NULL;
7293 }
7294
7295
7296 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7297 PyObject *resultobj = 0;
7298 wxRect *arg1 = (wxRect *) 0 ;
7299 wxRect *arg2 = 0 ;
7300 bool result;
7301 void *argp1 = 0 ;
7302 int res1 = 0 ;
7303 wxRect temp2 ;
7304 PyObject * obj0 = 0 ;
7305 PyObject * obj1 = 0 ;
7306 char * kwnames[] = {
7307 (char *) "self",(char *) "rect", NULL
7308 };
7309
7310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7312 if (!SWIG_IsOK(res1)) {
7313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect const *""'");
7314 }
7315 arg1 = reinterpret_cast< wxRect * >(argp1);
7316 {
7317 arg2 = &temp2;
7318 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7319 }
7320 {
7321 PyThreadState* __tstate = wxPyBeginAllowThreads();
7322 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
7323 wxPyEndAllowThreads(__tstate);
7324 if (PyErr_Occurred()) SWIG_fail;
7325 }
7326 {
7327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7328 }
7329 return resultobj;
7330 fail:
7331 return NULL;
7332 }
7333
7334
7335 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7336 PyObject *resultobj = 0;
7337 wxRect *arg1 = (wxRect *) 0 ;
7338 int arg2 ;
7339 int arg3 ;
7340 bool result;
7341 void *argp1 = 0 ;
7342 int res1 = 0 ;
7343 int val2 ;
7344 int ecode2 = 0 ;
7345 int val3 ;
7346 int ecode3 = 0 ;
7347 PyObject * obj0 = 0 ;
7348 PyObject * obj1 = 0 ;
7349 PyObject * obj2 = 0 ;
7350 char * kwnames[] = {
7351 (char *) "self",(char *) "x",(char *) "y", NULL
7352 };
7353
7354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7356 if (!SWIG_IsOK(res1)) {
7357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7358 }
7359 arg1 = reinterpret_cast< wxRect * >(argp1);
7360 ecode2 = SWIG_AsVal_int(obj1, &val2);
7361 if (!SWIG_IsOK(ecode2)) {
7362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7363 }
7364 arg2 = static_cast< int >(val2);
7365 ecode3 = SWIG_AsVal_int(obj2, &val3);
7366 if (!SWIG_IsOK(ecode3)) {
7367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7368 }
7369 arg3 = static_cast< int >(val3);
7370 {
7371 PyThreadState* __tstate = wxPyBeginAllowThreads();
7372 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7373 wxPyEndAllowThreads(__tstate);
7374 if (PyErr_Occurred()) SWIG_fail;
7375 }
7376 {
7377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7378 }
7379 return resultobj;
7380 fail:
7381 return NULL;
7382 }
7383
7384
7385 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7386 PyObject *resultobj = 0;
7387 wxRect *arg1 = (wxRect *) 0 ;
7388 wxPoint *arg2 = 0 ;
7389 bool result;
7390 void *argp1 = 0 ;
7391 int res1 = 0 ;
7392 wxPoint temp2 ;
7393 PyObject * obj0 = 0 ;
7394 PyObject * obj1 = 0 ;
7395 char * kwnames[] = {
7396 (char *) "self",(char *) "pt", NULL
7397 };
7398
7399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7401 if (!SWIG_IsOK(res1)) {
7402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7403 }
7404 arg1 = reinterpret_cast< wxRect * >(argp1);
7405 {
7406 arg2 = &temp2;
7407 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7408 }
7409 {
7410 PyThreadState* __tstate = wxPyBeginAllowThreads();
7411 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7412 wxPyEndAllowThreads(__tstate);
7413 if (PyErr_Occurred()) SWIG_fail;
7414 }
7415 {
7416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7417 }
7418 return resultobj;
7419 fail:
7420 return NULL;
7421 }
7422
7423
7424 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7425 PyObject *resultobj = 0;
7426 wxRect *arg1 = (wxRect *) 0 ;
7427 wxRect *arg2 = 0 ;
7428 bool result;
7429 void *argp1 = 0 ;
7430 int res1 = 0 ;
7431 wxRect temp2 ;
7432 PyObject * obj0 = 0 ;
7433 PyObject * obj1 = 0 ;
7434 char * kwnames[] = {
7435 (char *) "self",(char *) "rect", NULL
7436 };
7437
7438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7440 if (!SWIG_IsOK(res1)) {
7441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7442 }
7443 arg1 = reinterpret_cast< wxRect * >(argp1);
7444 {
7445 arg2 = &temp2;
7446 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7447 }
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7451 wxPyEndAllowThreads(__tstate);
7452 if (PyErr_Occurred()) SWIG_fail;
7453 }
7454 {
7455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7456 }
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7464 PyObject *resultobj = 0;
7465 wxRect *arg1 = (wxRect *) 0 ;
7466 wxRect *arg2 = 0 ;
7467 int arg3 = (int) wxBOTH ;
7468 wxRect result;
7469 void *argp1 = 0 ;
7470 int res1 = 0 ;
7471 wxRect temp2 ;
7472 int val3 ;
7473 int ecode3 = 0 ;
7474 PyObject * obj0 = 0 ;
7475 PyObject * obj1 = 0 ;
7476 PyObject * obj2 = 0 ;
7477 char * kwnames[] = {
7478 (char *) "self",(char *) "r",(char *) "dir", NULL
7479 };
7480
7481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7483 if (!SWIG_IsOK(res1)) {
7484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7485 }
7486 arg1 = reinterpret_cast< wxRect * >(argp1);
7487 {
7488 arg2 = &temp2;
7489 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7490 }
7491 if (obj2) {
7492 ecode3 = SWIG_AsVal_int(obj2, &val3);
7493 if (!SWIG_IsOK(ecode3)) {
7494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7495 }
7496 arg3 = static_cast< int >(val3);
7497 }
7498 {
7499 PyThreadState* __tstate = wxPyBeginAllowThreads();
7500 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7501 wxPyEndAllowThreads(__tstate);
7502 if (PyErr_Occurred()) SWIG_fail;
7503 }
7504 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7505 return resultobj;
7506 fail:
7507 return NULL;
7508 }
7509
7510
7511 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7512 PyObject *resultobj = 0;
7513 wxRect *arg1 = (wxRect *) 0 ;
7514 int arg2 ;
7515 void *argp1 = 0 ;
7516 int res1 = 0 ;
7517 int val2 ;
7518 int ecode2 = 0 ;
7519 PyObject *swig_obj[2] ;
7520
7521 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7523 if (!SWIG_IsOK(res1)) {
7524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7525 }
7526 arg1 = reinterpret_cast< wxRect * >(argp1);
7527 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7528 if (!SWIG_IsOK(ecode2)) {
7529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7530 }
7531 arg2 = static_cast< int >(val2);
7532 if (arg1) (arg1)->x = arg2;
7533
7534 resultobj = SWIG_Py_Void();
7535 return resultobj;
7536 fail:
7537 return NULL;
7538 }
7539
7540
7541 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7542 PyObject *resultobj = 0;
7543 wxRect *arg1 = (wxRect *) 0 ;
7544 int result;
7545 void *argp1 = 0 ;
7546 int res1 = 0 ;
7547 PyObject *swig_obj[1] ;
7548
7549 if (!args) SWIG_fail;
7550 swig_obj[0] = args;
7551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7552 if (!SWIG_IsOK(res1)) {
7553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7554 }
7555 arg1 = reinterpret_cast< wxRect * >(argp1);
7556 result = (int) ((arg1)->x);
7557 resultobj = SWIG_From_int(static_cast< int >(result));
7558 return resultobj;
7559 fail:
7560 return NULL;
7561 }
7562
7563
7564 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7565 PyObject *resultobj = 0;
7566 wxRect *arg1 = (wxRect *) 0 ;
7567 int arg2 ;
7568 void *argp1 = 0 ;
7569 int res1 = 0 ;
7570 int val2 ;
7571 int ecode2 = 0 ;
7572 PyObject *swig_obj[2] ;
7573
7574 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7576 if (!SWIG_IsOK(res1)) {
7577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7578 }
7579 arg1 = reinterpret_cast< wxRect * >(argp1);
7580 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7581 if (!SWIG_IsOK(ecode2)) {
7582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7583 }
7584 arg2 = static_cast< int >(val2);
7585 if (arg1) (arg1)->y = arg2;
7586
7587 resultobj = SWIG_Py_Void();
7588 return resultobj;
7589 fail:
7590 return NULL;
7591 }
7592
7593
7594 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7595 PyObject *resultobj = 0;
7596 wxRect *arg1 = (wxRect *) 0 ;
7597 int result;
7598 void *argp1 = 0 ;
7599 int res1 = 0 ;
7600 PyObject *swig_obj[1] ;
7601
7602 if (!args) SWIG_fail;
7603 swig_obj[0] = args;
7604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7605 if (!SWIG_IsOK(res1)) {
7606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7607 }
7608 arg1 = reinterpret_cast< wxRect * >(argp1);
7609 result = (int) ((arg1)->y);
7610 resultobj = SWIG_From_int(static_cast< int >(result));
7611 return resultobj;
7612 fail:
7613 return NULL;
7614 }
7615
7616
7617 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7618 PyObject *resultobj = 0;
7619 wxRect *arg1 = (wxRect *) 0 ;
7620 int arg2 ;
7621 void *argp1 = 0 ;
7622 int res1 = 0 ;
7623 int val2 ;
7624 int ecode2 = 0 ;
7625 PyObject *swig_obj[2] ;
7626
7627 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7629 if (!SWIG_IsOK(res1)) {
7630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7631 }
7632 arg1 = reinterpret_cast< wxRect * >(argp1);
7633 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7634 if (!SWIG_IsOK(ecode2)) {
7635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7636 }
7637 arg2 = static_cast< int >(val2);
7638 if (arg1) (arg1)->width = arg2;
7639
7640 resultobj = SWIG_Py_Void();
7641 return resultobj;
7642 fail:
7643 return NULL;
7644 }
7645
7646
7647 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7648 PyObject *resultobj = 0;
7649 wxRect *arg1 = (wxRect *) 0 ;
7650 int result;
7651 void *argp1 = 0 ;
7652 int res1 = 0 ;
7653 PyObject *swig_obj[1] ;
7654
7655 if (!args) SWIG_fail;
7656 swig_obj[0] = args;
7657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7658 if (!SWIG_IsOK(res1)) {
7659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7660 }
7661 arg1 = reinterpret_cast< wxRect * >(argp1);
7662 result = (int) ((arg1)->width);
7663 resultobj = SWIG_From_int(static_cast< int >(result));
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7671 PyObject *resultobj = 0;
7672 wxRect *arg1 = (wxRect *) 0 ;
7673 int arg2 ;
7674 void *argp1 = 0 ;
7675 int res1 = 0 ;
7676 int val2 ;
7677 int ecode2 = 0 ;
7678 PyObject *swig_obj[2] ;
7679
7680 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7682 if (!SWIG_IsOK(res1)) {
7683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7684 }
7685 arg1 = reinterpret_cast< wxRect * >(argp1);
7686 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7687 if (!SWIG_IsOK(ecode2)) {
7688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7689 }
7690 arg2 = static_cast< int >(val2);
7691 if (arg1) (arg1)->height = arg2;
7692
7693 resultobj = SWIG_Py_Void();
7694 return resultobj;
7695 fail:
7696 return NULL;
7697 }
7698
7699
7700 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7701 PyObject *resultobj = 0;
7702 wxRect *arg1 = (wxRect *) 0 ;
7703 int result;
7704 void *argp1 = 0 ;
7705 int res1 = 0 ;
7706 PyObject *swig_obj[1] ;
7707
7708 if (!args) SWIG_fail;
7709 swig_obj[0] = args;
7710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7711 if (!SWIG_IsOK(res1)) {
7712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7713 }
7714 arg1 = reinterpret_cast< wxRect * >(argp1);
7715 result = (int) ((arg1)->height);
7716 resultobj = SWIG_From_int(static_cast< int >(result));
7717 return resultobj;
7718 fail:
7719 return NULL;
7720 }
7721
7722
7723 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7724 PyObject *resultobj = 0;
7725 wxRect *arg1 = (wxRect *) 0 ;
7726 int arg2 = (int) 0 ;
7727 int arg3 = (int) 0 ;
7728 int arg4 = (int) 0 ;
7729 int arg5 = (int) 0 ;
7730 void *argp1 = 0 ;
7731 int res1 = 0 ;
7732 int val2 ;
7733 int ecode2 = 0 ;
7734 int val3 ;
7735 int ecode3 = 0 ;
7736 int val4 ;
7737 int ecode4 = 0 ;
7738 int val5 ;
7739 int ecode5 = 0 ;
7740 PyObject * obj0 = 0 ;
7741 PyObject * obj1 = 0 ;
7742 PyObject * obj2 = 0 ;
7743 PyObject * obj3 = 0 ;
7744 PyObject * obj4 = 0 ;
7745 char * kwnames[] = {
7746 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7747 };
7748
7749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7751 if (!SWIG_IsOK(res1)) {
7752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7753 }
7754 arg1 = reinterpret_cast< wxRect * >(argp1);
7755 if (obj1) {
7756 ecode2 = SWIG_AsVal_int(obj1, &val2);
7757 if (!SWIG_IsOK(ecode2)) {
7758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7759 }
7760 arg2 = static_cast< int >(val2);
7761 }
7762 if (obj2) {
7763 ecode3 = SWIG_AsVal_int(obj2, &val3);
7764 if (!SWIG_IsOK(ecode3)) {
7765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7766 }
7767 arg3 = static_cast< int >(val3);
7768 }
7769 if (obj3) {
7770 ecode4 = SWIG_AsVal_int(obj3, &val4);
7771 if (!SWIG_IsOK(ecode4)) {
7772 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7773 }
7774 arg4 = static_cast< int >(val4);
7775 }
7776 if (obj4) {
7777 ecode5 = SWIG_AsVal_int(obj4, &val5);
7778 if (!SWIG_IsOK(ecode5)) {
7779 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7780 }
7781 arg5 = static_cast< int >(val5);
7782 }
7783 {
7784 PyThreadState* __tstate = wxPyBeginAllowThreads();
7785 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7786 wxPyEndAllowThreads(__tstate);
7787 if (PyErr_Occurred()) SWIG_fail;
7788 }
7789 resultobj = SWIG_Py_Void();
7790 return resultobj;
7791 fail:
7792 return NULL;
7793 }
7794
7795
7796 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7797 PyObject *resultobj = 0;
7798 wxRect *arg1 = (wxRect *) 0 ;
7799 PyObject *result = 0 ;
7800 void *argp1 = 0 ;
7801 int res1 = 0 ;
7802 PyObject *swig_obj[1] ;
7803
7804 if (!args) SWIG_fail;
7805 swig_obj[0] = args;
7806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7807 if (!SWIG_IsOK(res1)) {
7808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7809 }
7810 arg1 = reinterpret_cast< wxRect * >(argp1);
7811 {
7812 PyThreadState* __tstate = wxPyBeginAllowThreads();
7813 result = (PyObject *)wxRect_Get(arg1);
7814 wxPyEndAllowThreads(__tstate);
7815 if (PyErr_Occurred()) SWIG_fail;
7816 }
7817 resultobj = result;
7818 return resultobj;
7819 fail:
7820 return NULL;
7821 }
7822
7823
7824 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7825 PyObject *obj;
7826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7827 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7828 return SWIG_Py_Void();
7829 }
7830
7831 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7832 return SWIG_Python_InitShadowInstance(args);
7833 }
7834
7835 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7836 PyObject *resultobj = 0;
7837 wxRect *arg1 = (wxRect *) 0 ;
7838 wxRect *arg2 = (wxRect *) 0 ;
7839 PyObject *result = 0 ;
7840 void *argp1 = 0 ;
7841 int res1 = 0 ;
7842 void *argp2 = 0 ;
7843 int res2 = 0 ;
7844 PyObject * obj0 = 0 ;
7845 PyObject * obj1 = 0 ;
7846 char * kwnames[] = {
7847 (char *) "r1",(char *) "r2", NULL
7848 };
7849
7850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7852 if (!SWIG_IsOK(res1)) {
7853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7854 }
7855 arg1 = reinterpret_cast< wxRect * >(argp1);
7856 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7857 if (!SWIG_IsOK(res2)) {
7858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7859 }
7860 arg2 = reinterpret_cast< wxRect * >(argp2);
7861 {
7862 if (!wxPyCheckForApp()) SWIG_fail;
7863 PyThreadState* __tstate = wxPyBeginAllowThreads();
7864 result = (PyObject *)wxIntersectRect(arg1,arg2);
7865 wxPyEndAllowThreads(__tstate);
7866 if (PyErr_Occurred()) SWIG_fail;
7867 }
7868 resultobj = result;
7869 return resultobj;
7870 fail:
7871 return NULL;
7872 }
7873
7874
7875 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7876 PyObject *resultobj = 0;
7877 double arg1 = (double) 0.0 ;
7878 double arg2 = (double) 0.0 ;
7879 wxPoint2D *result = 0 ;
7880 double val1 ;
7881 int ecode1 = 0 ;
7882 double val2 ;
7883 int ecode2 = 0 ;
7884 PyObject * obj0 = 0 ;
7885 PyObject * obj1 = 0 ;
7886 char * kwnames[] = {
7887 (char *) "x",(char *) "y", NULL
7888 };
7889
7890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7891 if (obj0) {
7892 ecode1 = SWIG_AsVal_double(obj0, &val1);
7893 if (!SWIG_IsOK(ecode1)) {
7894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7895 }
7896 arg1 = static_cast< double >(val1);
7897 }
7898 if (obj1) {
7899 ecode2 = SWIG_AsVal_double(obj1, &val2);
7900 if (!SWIG_IsOK(ecode2)) {
7901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7902 }
7903 arg2 = static_cast< double >(val2);
7904 }
7905 {
7906 PyThreadState* __tstate = wxPyBeginAllowThreads();
7907 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7908 wxPyEndAllowThreads(__tstate);
7909 if (PyErr_Occurred()) SWIG_fail;
7910 }
7911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7912 return resultobj;
7913 fail:
7914 return NULL;
7915 }
7916
7917
7918 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7919 PyObject *resultobj = 0;
7920 wxPoint2D *arg1 = 0 ;
7921 wxPoint2D *result = 0 ;
7922 wxPoint2D temp1 ;
7923 PyObject * obj0 = 0 ;
7924 char * kwnames[] = {
7925 (char *) "pt", NULL
7926 };
7927
7928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
7929 {
7930 arg1 = &temp1;
7931 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
7932 }
7933 {
7934 PyThreadState* __tstate = wxPyBeginAllowThreads();
7935 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
7936 wxPyEndAllowThreads(__tstate);
7937 if (PyErr_Occurred()) SWIG_fail;
7938 }
7939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7940 return resultobj;
7941 fail:
7942 return NULL;
7943 }
7944
7945
7946 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7947 PyObject *resultobj = 0;
7948 wxPoint *arg1 = 0 ;
7949 wxPoint2D *result = 0 ;
7950 wxPoint temp1 ;
7951 PyObject * obj0 = 0 ;
7952 char * kwnames[] = {
7953 (char *) "pt", NULL
7954 };
7955
7956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
7957 {
7958 arg1 = &temp1;
7959 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7960 }
7961 {
7962 PyThreadState* __tstate = wxPyBeginAllowThreads();
7963 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
7964 wxPyEndAllowThreads(__tstate);
7965 if (PyErr_Occurred()) SWIG_fail;
7966 }
7967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7968 return resultobj;
7969 fail:
7970 return NULL;
7971 }
7972
7973
7974 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7975 PyObject *resultobj = 0;
7976 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7977 int *arg2 = (int *) 0 ;
7978 int *arg3 = (int *) 0 ;
7979 void *argp1 = 0 ;
7980 int res1 = 0 ;
7981 int temp2 ;
7982 int res2 = SWIG_TMPOBJ ;
7983 int temp3 ;
7984 int res3 = SWIG_TMPOBJ ;
7985 PyObject *swig_obj[1] ;
7986
7987 arg2 = &temp2;
7988 arg3 = &temp3;
7989 if (!args) SWIG_fail;
7990 swig_obj[0] = args;
7991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
7992 if (!SWIG_IsOK(res1)) {
7993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
7994 }
7995 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
7996 {
7997 PyThreadState* __tstate = wxPyBeginAllowThreads();
7998 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
7999 wxPyEndAllowThreads(__tstate);
8000 if (PyErr_Occurred()) SWIG_fail;
8001 }
8002 resultobj = SWIG_Py_Void();
8003 if (SWIG_IsTmpObj(res2)) {
8004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8005 } else {
8006 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8008 }
8009 if (SWIG_IsTmpObj(res3)) {
8010 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8011 } else {
8012 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8013 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8014 }
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8022 PyObject *resultobj = 0;
8023 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8024 int *arg2 = (int *) 0 ;
8025 int *arg3 = (int *) 0 ;
8026 void *argp1 = 0 ;
8027 int res1 = 0 ;
8028 int temp2 ;
8029 int res2 = SWIG_TMPOBJ ;
8030 int temp3 ;
8031 int res3 = SWIG_TMPOBJ ;
8032 PyObject *swig_obj[1] ;
8033
8034 arg2 = &temp2;
8035 arg3 = &temp3;
8036 if (!args) SWIG_fail;
8037 swig_obj[0] = args;
8038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8039 if (!SWIG_IsOK(res1)) {
8040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8041 }
8042 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8043 {
8044 PyThreadState* __tstate = wxPyBeginAllowThreads();
8045 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8046 wxPyEndAllowThreads(__tstate);
8047 if (PyErr_Occurred()) SWIG_fail;
8048 }
8049 resultobj = SWIG_Py_Void();
8050 if (SWIG_IsTmpObj(res2)) {
8051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8052 } else {
8053 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8054 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8055 }
8056 if (SWIG_IsTmpObj(res3)) {
8057 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8058 } else {
8059 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8060 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8061 }
8062 return resultobj;
8063 fail:
8064 return NULL;
8065 }
8066
8067
8068 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8069 PyObject *resultobj = 0;
8070 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8071 double result;
8072 void *argp1 = 0 ;
8073 int res1 = 0 ;
8074 PyObject *swig_obj[1] ;
8075
8076 if (!args) SWIG_fail;
8077 swig_obj[0] = args;
8078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8079 if (!SWIG_IsOK(res1)) {
8080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8081 }
8082 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8083 {
8084 PyThreadState* __tstate = wxPyBeginAllowThreads();
8085 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8086 wxPyEndAllowThreads(__tstate);
8087 if (PyErr_Occurred()) SWIG_fail;
8088 }
8089 resultobj = SWIG_From_double(static_cast< double >(result));
8090 return resultobj;
8091 fail:
8092 return NULL;
8093 }
8094
8095
8096 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8097 PyObject *resultobj = 0;
8098 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8099 double result;
8100 void *argp1 = 0 ;
8101 int res1 = 0 ;
8102 PyObject *swig_obj[1] ;
8103
8104 if (!args) SWIG_fail;
8105 swig_obj[0] = args;
8106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8107 if (!SWIG_IsOK(res1)) {
8108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8109 }
8110 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8111 {
8112 PyThreadState* __tstate = wxPyBeginAllowThreads();
8113 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8114 wxPyEndAllowThreads(__tstate);
8115 if (PyErr_Occurred()) SWIG_fail;
8116 }
8117 resultobj = SWIG_From_double(static_cast< double >(result));
8118 return resultobj;
8119 fail:
8120 return NULL;
8121 }
8122
8123
8124 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8125 PyObject *resultobj = 0;
8126 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8127 double arg2 ;
8128 void *argp1 = 0 ;
8129 int res1 = 0 ;
8130 double val2 ;
8131 int ecode2 = 0 ;
8132 PyObject * obj0 = 0 ;
8133 PyObject * obj1 = 0 ;
8134 char * kwnames[] = {
8135 (char *) "self",(char *) "length", NULL
8136 };
8137
8138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8140 if (!SWIG_IsOK(res1)) {
8141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8142 }
8143 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8144 ecode2 = SWIG_AsVal_double(obj1, &val2);
8145 if (!SWIG_IsOK(ecode2)) {
8146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8147 }
8148 arg2 = static_cast< double >(val2);
8149 {
8150 PyThreadState* __tstate = wxPyBeginAllowThreads();
8151 (arg1)->SetVectorLength(arg2);
8152 wxPyEndAllowThreads(__tstate);
8153 if (PyErr_Occurred()) SWIG_fail;
8154 }
8155 resultobj = SWIG_Py_Void();
8156 return resultobj;
8157 fail:
8158 return NULL;
8159 }
8160
8161
8162 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8163 PyObject *resultobj = 0;
8164 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8165 double arg2 ;
8166 void *argp1 = 0 ;
8167 int res1 = 0 ;
8168 double val2 ;
8169 int ecode2 = 0 ;
8170 PyObject * obj0 = 0 ;
8171 PyObject * obj1 = 0 ;
8172 char * kwnames[] = {
8173 (char *) "self",(char *) "degrees", NULL
8174 };
8175
8176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8178 if (!SWIG_IsOK(res1)) {
8179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8180 }
8181 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8182 ecode2 = SWIG_AsVal_double(obj1, &val2);
8183 if (!SWIG_IsOK(ecode2)) {
8184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8185 }
8186 arg2 = static_cast< double >(val2);
8187 {
8188 PyThreadState* __tstate = wxPyBeginAllowThreads();
8189 (arg1)->SetVectorAngle(arg2);
8190 wxPyEndAllowThreads(__tstate);
8191 if (PyErr_Occurred()) SWIG_fail;
8192 }
8193 resultobj = SWIG_Py_Void();
8194 return resultobj;
8195 fail:
8196 return NULL;
8197 }
8198
8199
8200 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8201 PyObject *resultobj = 0;
8202 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8203 wxPoint2D *arg2 = 0 ;
8204 double result;
8205 void *argp1 = 0 ;
8206 int res1 = 0 ;
8207 wxPoint2D temp2 ;
8208 PyObject * obj0 = 0 ;
8209 PyObject * obj1 = 0 ;
8210 char * kwnames[] = {
8211 (char *) "self",(char *) "pt", NULL
8212 };
8213
8214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8216 if (!SWIG_IsOK(res1)) {
8217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8218 }
8219 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8220 {
8221 arg2 = &temp2;
8222 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8223 }
8224 {
8225 PyThreadState* __tstate = wxPyBeginAllowThreads();
8226 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8227 wxPyEndAllowThreads(__tstate);
8228 if (PyErr_Occurred()) SWIG_fail;
8229 }
8230 resultobj = SWIG_From_double(static_cast< double >(result));
8231 return resultobj;
8232 fail:
8233 return NULL;
8234 }
8235
8236
8237 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8238 PyObject *resultobj = 0;
8239 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8240 wxPoint2D *arg2 = 0 ;
8241 double result;
8242 void *argp1 = 0 ;
8243 int res1 = 0 ;
8244 wxPoint2D temp2 ;
8245 PyObject * obj0 = 0 ;
8246 PyObject * obj1 = 0 ;
8247 char * kwnames[] = {
8248 (char *) "self",(char *) "pt", NULL
8249 };
8250
8251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8253 if (!SWIG_IsOK(res1)) {
8254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8255 }
8256 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8257 {
8258 arg2 = &temp2;
8259 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8260 }
8261 {
8262 PyThreadState* __tstate = wxPyBeginAllowThreads();
8263 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8264 wxPyEndAllowThreads(__tstate);
8265 if (PyErr_Occurred()) SWIG_fail;
8266 }
8267 resultobj = SWIG_From_double(static_cast< double >(result));
8268 return resultobj;
8269 fail:
8270 return NULL;
8271 }
8272
8273
8274 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8275 PyObject *resultobj = 0;
8276 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8277 wxPoint2D *arg2 = 0 ;
8278 double result;
8279 void *argp1 = 0 ;
8280 int res1 = 0 ;
8281 wxPoint2D temp2 ;
8282 PyObject * obj0 = 0 ;
8283 PyObject * obj1 = 0 ;
8284 char * kwnames[] = {
8285 (char *) "self",(char *) "vec", NULL
8286 };
8287
8288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8290 if (!SWIG_IsOK(res1)) {
8291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8292 }
8293 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8294 {
8295 arg2 = &temp2;
8296 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8297 }
8298 {
8299 PyThreadState* __tstate = wxPyBeginAllowThreads();
8300 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8301 wxPyEndAllowThreads(__tstate);
8302 if (PyErr_Occurred()) SWIG_fail;
8303 }
8304 resultobj = SWIG_From_double(static_cast< double >(result));
8305 return resultobj;
8306 fail:
8307 return NULL;
8308 }
8309
8310
8311 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8312 PyObject *resultobj = 0;
8313 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8314 wxPoint2D *arg2 = 0 ;
8315 double result;
8316 void *argp1 = 0 ;
8317 int res1 = 0 ;
8318 wxPoint2D temp2 ;
8319 PyObject * obj0 = 0 ;
8320 PyObject * obj1 = 0 ;
8321 char * kwnames[] = {
8322 (char *) "self",(char *) "vec", NULL
8323 };
8324
8325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8327 if (!SWIG_IsOK(res1)) {
8328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8329 }
8330 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8331 {
8332 arg2 = &temp2;
8333 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8334 }
8335 {
8336 PyThreadState* __tstate = wxPyBeginAllowThreads();
8337 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8338 wxPyEndAllowThreads(__tstate);
8339 if (PyErr_Occurred()) SWIG_fail;
8340 }
8341 resultobj = SWIG_From_double(static_cast< double >(result));
8342 return resultobj;
8343 fail:
8344 return NULL;
8345 }
8346
8347
8348 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8349 PyObject *resultobj = 0;
8350 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8351 wxPoint2D result;
8352 void *argp1 = 0 ;
8353 int res1 = 0 ;
8354 PyObject *swig_obj[1] ;
8355
8356 if (!args) SWIG_fail;
8357 swig_obj[0] = args;
8358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8359 if (!SWIG_IsOK(res1)) {
8360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8361 }
8362 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8363 {
8364 PyThreadState* __tstate = wxPyBeginAllowThreads();
8365 result = (arg1)->operator -();
8366 wxPyEndAllowThreads(__tstate);
8367 if (PyErr_Occurred()) SWIG_fail;
8368 }
8369 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8370 return resultobj;
8371 fail:
8372 return NULL;
8373 }
8374
8375
8376 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8377 PyObject *resultobj = 0;
8378 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8379 wxPoint2D *arg2 = 0 ;
8380 wxPoint2D *result = 0 ;
8381 void *argp1 = 0 ;
8382 int res1 = 0 ;
8383 wxPoint2D temp2 ;
8384 PyObject * obj0 = 0 ;
8385 PyObject * obj1 = 0 ;
8386 char * kwnames[] = {
8387 (char *) "self",(char *) "pt", NULL
8388 };
8389
8390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8392 if (!SWIG_IsOK(res1)) {
8393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8394 }
8395 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8396 {
8397 arg2 = &temp2;
8398 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8399 }
8400 {
8401 PyThreadState* __tstate = wxPyBeginAllowThreads();
8402 {
8403 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8404 result = (wxPoint2D *) &_result_ref;
8405 }
8406 wxPyEndAllowThreads(__tstate);
8407 if (PyErr_Occurred()) SWIG_fail;
8408 }
8409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8410 return resultobj;
8411 fail:
8412 return NULL;
8413 }
8414
8415
8416 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8417 PyObject *resultobj = 0;
8418 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8419 wxPoint2D *arg2 = 0 ;
8420 wxPoint2D *result = 0 ;
8421 void *argp1 = 0 ;
8422 int res1 = 0 ;
8423 wxPoint2D temp2 ;
8424 PyObject * obj0 = 0 ;
8425 PyObject * obj1 = 0 ;
8426 char * kwnames[] = {
8427 (char *) "self",(char *) "pt", NULL
8428 };
8429
8430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8432 if (!SWIG_IsOK(res1)) {
8433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8434 }
8435 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8436 {
8437 arg2 = &temp2;
8438 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8439 }
8440 {
8441 PyThreadState* __tstate = wxPyBeginAllowThreads();
8442 {
8443 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8444 result = (wxPoint2D *) &_result_ref;
8445 }
8446 wxPyEndAllowThreads(__tstate);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj = 0;
8458 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8459 wxPoint2D *arg2 = 0 ;
8460 wxPoint2D *result = 0 ;
8461 void *argp1 = 0 ;
8462 int res1 = 0 ;
8463 wxPoint2D temp2 ;
8464 PyObject * obj0 = 0 ;
8465 PyObject * obj1 = 0 ;
8466 char * kwnames[] = {
8467 (char *) "self",(char *) "pt", NULL
8468 };
8469
8470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8472 if (!SWIG_IsOK(res1)) {
8473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8474 }
8475 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8476 {
8477 arg2 = &temp2;
8478 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8479 }
8480 {
8481 PyThreadState* __tstate = wxPyBeginAllowThreads();
8482 {
8483 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8484 result = (wxPoint2D *) &_result_ref;
8485 }
8486 wxPyEndAllowThreads(__tstate);
8487 if (PyErr_Occurred()) SWIG_fail;
8488 }
8489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8490 return resultobj;
8491 fail:
8492 return NULL;
8493 }
8494
8495
8496 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8497 PyObject *resultobj = 0;
8498 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8499 wxPoint2D *arg2 = 0 ;
8500 wxPoint2D *result = 0 ;
8501 void *argp1 = 0 ;
8502 int res1 = 0 ;
8503 wxPoint2D temp2 ;
8504 PyObject * obj0 = 0 ;
8505 PyObject * obj1 = 0 ;
8506 char * kwnames[] = {
8507 (char *) "self",(char *) "pt", NULL
8508 };
8509
8510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8512 if (!SWIG_IsOK(res1)) {
8513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8514 }
8515 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8516 {
8517 arg2 = &temp2;
8518 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8519 }
8520 {
8521 PyThreadState* __tstate = wxPyBeginAllowThreads();
8522 {
8523 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8524 result = (wxPoint2D *) &_result_ref;
8525 }
8526 wxPyEndAllowThreads(__tstate);
8527 if (PyErr_Occurred()) SWIG_fail;
8528 }
8529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8530 return resultobj;
8531 fail:
8532 return NULL;
8533 }
8534
8535
8536 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8537 PyObject *resultobj = 0;
8538 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8539 wxPoint2D *arg2 = 0 ;
8540 bool result;
8541 void *argp1 = 0 ;
8542 int res1 = 0 ;
8543 wxPoint2D temp2 ;
8544 PyObject * obj0 = 0 ;
8545 PyObject * obj1 = 0 ;
8546 char * kwnames[] = {
8547 (char *) "self",(char *) "pt", NULL
8548 };
8549
8550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8552 if (!SWIG_IsOK(res1)) {
8553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8554 }
8555 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8556 {
8557 arg2 = &temp2;
8558 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8559 }
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
8563 wxPyEndAllowThreads(__tstate);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 {
8567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8568 }
8569 return resultobj;
8570 fail:
8571 return NULL;
8572 }
8573
8574
8575 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8576 PyObject *resultobj = 0;
8577 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8578 wxPoint2D *arg2 = 0 ;
8579 bool result;
8580 void *argp1 = 0 ;
8581 int res1 = 0 ;
8582 wxPoint2D temp2 ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 char * kwnames[] = {
8586 (char *) "self",(char *) "pt", NULL
8587 };
8588
8589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8591 if (!SWIG_IsOK(res1)) {
8592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8593 }
8594 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8595 {
8596 arg2 = &temp2;
8597 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8598 }
8599 {
8600 PyThreadState* __tstate = wxPyBeginAllowThreads();
8601 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
8602 wxPyEndAllowThreads(__tstate);
8603 if (PyErr_Occurred()) SWIG_fail;
8604 }
8605 {
8606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8607 }
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8615 PyObject *resultobj = 0;
8616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8617 double arg2 ;
8618 void *argp1 = 0 ;
8619 int res1 = 0 ;
8620 double val2 ;
8621 int ecode2 = 0 ;
8622 PyObject *swig_obj[2] ;
8623
8624 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8626 if (!SWIG_IsOK(res1)) {
8627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8628 }
8629 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8630 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8631 if (!SWIG_IsOK(ecode2)) {
8632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8633 }
8634 arg2 = static_cast< double >(val2);
8635 if (arg1) (arg1)->m_x = arg2;
8636
8637 resultobj = SWIG_Py_Void();
8638 return resultobj;
8639 fail:
8640 return NULL;
8641 }
8642
8643
8644 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8645 PyObject *resultobj = 0;
8646 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8647 double result;
8648 void *argp1 = 0 ;
8649 int res1 = 0 ;
8650 PyObject *swig_obj[1] ;
8651
8652 if (!args) SWIG_fail;
8653 swig_obj[0] = args;
8654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8655 if (!SWIG_IsOK(res1)) {
8656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8657 }
8658 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8659 result = (double) ((arg1)->m_x);
8660 resultobj = SWIG_From_double(static_cast< double >(result));
8661 return resultobj;
8662 fail:
8663 return NULL;
8664 }
8665
8666
8667 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8668 PyObject *resultobj = 0;
8669 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8670 double arg2 ;
8671 void *argp1 = 0 ;
8672 int res1 = 0 ;
8673 double val2 ;
8674 int ecode2 = 0 ;
8675 PyObject *swig_obj[2] ;
8676
8677 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8679 if (!SWIG_IsOK(res1)) {
8680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8681 }
8682 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8683 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8684 if (!SWIG_IsOK(ecode2)) {
8685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8686 }
8687 arg2 = static_cast< double >(val2);
8688 if (arg1) (arg1)->m_y = arg2;
8689
8690 resultobj = SWIG_Py_Void();
8691 return resultobj;
8692 fail:
8693 return NULL;
8694 }
8695
8696
8697 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8698 PyObject *resultobj = 0;
8699 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8700 double result;
8701 void *argp1 = 0 ;
8702 int res1 = 0 ;
8703 PyObject *swig_obj[1] ;
8704
8705 if (!args) SWIG_fail;
8706 swig_obj[0] = args;
8707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8708 if (!SWIG_IsOK(res1)) {
8709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8710 }
8711 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8712 result = (double) ((arg1)->m_y);
8713 resultobj = SWIG_From_double(static_cast< double >(result));
8714 return resultobj;
8715 fail:
8716 return NULL;
8717 }
8718
8719
8720 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8721 PyObject *resultobj = 0;
8722 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8723 double arg2 = (double) 0 ;
8724 double arg3 = (double) 0 ;
8725 void *argp1 = 0 ;
8726 int res1 = 0 ;
8727 double val2 ;
8728 int ecode2 = 0 ;
8729 double val3 ;
8730 int ecode3 = 0 ;
8731 PyObject * obj0 = 0 ;
8732 PyObject * obj1 = 0 ;
8733 PyObject * obj2 = 0 ;
8734 char * kwnames[] = {
8735 (char *) "self",(char *) "x",(char *) "y", NULL
8736 };
8737
8738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8740 if (!SWIG_IsOK(res1)) {
8741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8742 }
8743 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8744 if (obj1) {
8745 ecode2 = SWIG_AsVal_double(obj1, &val2);
8746 if (!SWIG_IsOK(ecode2)) {
8747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8748 }
8749 arg2 = static_cast< double >(val2);
8750 }
8751 if (obj2) {
8752 ecode3 = SWIG_AsVal_double(obj2, &val3);
8753 if (!SWIG_IsOK(ecode3)) {
8754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8755 }
8756 arg3 = static_cast< double >(val3);
8757 }
8758 {
8759 PyThreadState* __tstate = wxPyBeginAllowThreads();
8760 wxPoint2D_Set(arg1,arg2,arg3);
8761 wxPyEndAllowThreads(__tstate);
8762 if (PyErr_Occurred()) SWIG_fail;
8763 }
8764 resultobj = SWIG_Py_Void();
8765 return resultobj;
8766 fail:
8767 return NULL;
8768 }
8769
8770
8771 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8772 PyObject *resultobj = 0;
8773 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8774 PyObject *result = 0 ;
8775 void *argp1 = 0 ;
8776 int res1 = 0 ;
8777 PyObject *swig_obj[1] ;
8778
8779 if (!args) SWIG_fail;
8780 swig_obj[0] = args;
8781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8784 }
8785 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8786 {
8787 PyThreadState* __tstate = wxPyBeginAllowThreads();
8788 result = (PyObject *)wxPoint2D_Get(arg1);
8789 wxPyEndAllowThreads(__tstate);
8790 if (PyErr_Occurred()) SWIG_fail;
8791 }
8792 resultobj = result;
8793 return resultobj;
8794 fail:
8795 return NULL;
8796 }
8797
8798
8799 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8800 PyObject *obj;
8801 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8802 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8803 return SWIG_Py_Void();
8804 }
8805
8806 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8807 return SWIG_Python_InitShadowInstance(args);
8808 }
8809
8810 SWIGINTERN int DefaultPosition_set(PyObject *) {
8811 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8812 return 1;
8813 }
8814
8815
8816 SWIGINTERN PyObject *DefaultPosition_get(void) {
8817 PyObject *pyobj = 0;
8818
8819 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8820 return pyobj;
8821 }
8822
8823
8824 SWIGINTERN int DefaultSize_set(PyObject *) {
8825 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8826 return 1;
8827 }
8828
8829
8830 SWIGINTERN PyObject *DefaultSize_get(void) {
8831 PyObject *pyobj = 0;
8832
8833 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8834 return pyobj;
8835 }
8836
8837
8838 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8839 PyObject *resultobj = 0;
8840 PyObject *arg1 = (PyObject *) 0 ;
8841 wxPyInputStream *result = 0 ;
8842 PyObject * obj0 = 0 ;
8843 char * kwnames[] = {
8844 (char *) "p", NULL
8845 };
8846
8847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8848 arg1 = obj0;
8849 {
8850 PyThreadState* __tstate = wxPyBeginAllowThreads();
8851 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8852 wxPyEndAllowThreads(__tstate);
8853 if (PyErr_Occurred()) SWIG_fail;
8854 }
8855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8856 return resultobj;
8857 fail:
8858 return NULL;
8859 }
8860
8861
8862 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8863 PyObject *resultobj = 0;
8864 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8865 void *argp1 = 0 ;
8866 int res1 = 0 ;
8867 PyObject *swig_obj[1] ;
8868
8869 if (!args) SWIG_fail;
8870 swig_obj[0] = args;
8871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8872 if (!SWIG_IsOK(res1)) {
8873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8874 }
8875 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8876 {
8877 PyThreadState* __tstate = wxPyBeginAllowThreads();
8878 delete arg1;
8879
8880 wxPyEndAllowThreads(__tstate);
8881 if (PyErr_Occurred()) SWIG_fail;
8882 }
8883 resultobj = SWIG_Py_Void();
8884 return resultobj;
8885 fail:
8886 return NULL;
8887 }
8888
8889
8890 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8891 PyObject *resultobj = 0;
8892 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8893 void *argp1 = 0 ;
8894 int res1 = 0 ;
8895 PyObject *swig_obj[1] ;
8896
8897 if (!args) SWIG_fail;
8898 swig_obj[0] = args;
8899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8900 if (!SWIG_IsOK(res1)) {
8901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8902 }
8903 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8904 {
8905 PyThreadState* __tstate = wxPyBeginAllowThreads();
8906 (arg1)->close();
8907 wxPyEndAllowThreads(__tstate);
8908 if (PyErr_Occurred()) SWIG_fail;
8909 }
8910 resultobj = SWIG_Py_Void();
8911 return resultobj;
8912 fail:
8913 return NULL;
8914 }
8915
8916
8917 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8918 PyObject *resultobj = 0;
8919 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8920 void *argp1 = 0 ;
8921 int res1 = 0 ;
8922 PyObject *swig_obj[1] ;
8923
8924 if (!args) SWIG_fail;
8925 swig_obj[0] = args;
8926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8927 if (!SWIG_IsOK(res1)) {
8928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8929 }
8930 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8931 {
8932 PyThreadState* __tstate = wxPyBeginAllowThreads();
8933 (arg1)->flush();
8934 wxPyEndAllowThreads(__tstate);
8935 if (PyErr_Occurred()) SWIG_fail;
8936 }
8937 resultobj = SWIG_Py_Void();
8938 return resultobj;
8939 fail:
8940 return NULL;
8941 }
8942
8943
8944 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8945 PyObject *resultobj = 0;
8946 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8947 bool result;
8948 void *argp1 = 0 ;
8949 int res1 = 0 ;
8950 PyObject *swig_obj[1] ;
8951
8952 if (!args) SWIG_fail;
8953 swig_obj[0] = args;
8954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8955 if (!SWIG_IsOK(res1)) {
8956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8957 }
8958 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8959 {
8960 PyThreadState* __tstate = wxPyBeginAllowThreads();
8961 result = (bool)(arg1)->eof();
8962 wxPyEndAllowThreads(__tstate);
8963 if (PyErr_Occurred()) SWIG_fail;
8964 }
8965 {
8966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8967 }
8968 return resultobj;
8969 fail:
8970 return NULL;
8971 }
8972
8973
8974 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj = 0;
8976 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8977 int arg2 = (int) -1 ;
8978 PyObject *result = 0 ;
8979 void *argp1 = 0 ;
8980 int res1 = 0 ;
8981 int val2 ;
8982 int ecode2 = 0 ;
8983 PyObject * obj0 = 0 ;
8984 PyObject * obj1 = 0 ;
8985 char * kwnames[] = {
8986 (char *) "self",(char *) "size", NULL
8987 };
8988
8989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
8990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8991 if (!SWIG_IsOK(res1)) {
8992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8993 }
8994 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8995 if (obj1) {
8996 ecode2 = SWIG_AsVal_int(obj1, &val2);
8997 if (!SWIG_IsOK(ecode2)) {
8998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
8999 }
9000 arg2 = static_cast< int >(val2);
9001 }
9002 {
9003 PyThreadState* __tstate = wxPyBeginAllowThreads();
9004 result = (PyObject *)(arg1)->read(arg2);
9005 wxPyEndAllowThreads(__tstate);
9006 if (PyErr_Occurred()) SWIG_fail;
9007 }
9008 resultobj = result;
9009 return resultobj;
9010 fail:
9011 return NULL;
9012 }
9013
9014
9015 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9016 PyObject *resultobj = 0;
9017 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9018 int arg2 = (int) -1 ;
9019 PyObject *result = 0 ;
9020 void *argp1 = 0 ;
9021 int res1 = 0 ;
9022 int val2 ;
9023 int ecode2 = 0 ;
9024 PyObject * obj0 = 0 ;
9025 PyObject * obj1 = 0 ;
9026 char * kwnames[] = {
9027 (char *) "self",(char *) "size", NULL
9028 };
9029
9030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9032 if (!SWIG_IsOK(res1)) {
9033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9034 }
9035 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9036 if (obj1) {
9037 ecode2 = SWIG_AsVal_int(obj1, &val2);
9038 if (!SWIG_IsOK(ecode2)) {
9039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9040 }
9041 arg2 = static_cast< int >(val2);
9042 }
9043 {
9044 PyThreadState* __tstate = wxPyBeginAllowThreads();
9045 result = (PyObject *)(arg1)->readline(arg2);
9046 wxPyEndAllowThreads(__tstate);
9047 if (PyErr_Occurred()) SWIG_fail;
9048 }
9049 resultobj = result;
9050 return resultobj;
9051 fail:
9052 return NULL;
9053 }
9054
9055
9056 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9057 PyObject *resultobj = 0;
9058 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9059 int arg2 = (int) -1 ;
9060 PyObject *result = 0 ;
9061 void *argp1 = 0 ;
9062 int res1 = 0 ;
9063 int val2 ;
9064 int ecode2 = 0 ;
9065 PyObject * obj0 = 0 ;
9066 PyObject * obj1 = 0 ;
9067 char * kwnames[] = {
9068 (char *) "self",(char *) "sizehint", NULL
9069 };
9070
9071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9073 if (!SWIG_IsOK(res1)) {
9074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9075 }
9076 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9077 if (obj1) {
9078 ecode2 = SWIG_AsVal_int(obj1, &val2);
9079 if (!SWIG_IsOK(ecode2)) {
9080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9081 }
9082 arg2 = static_cast< int >(val2);
9083 }
9084 {
9085 PyThreadState* __tstate = wxPyBeginAllowThreads();
9086 result = (PyObject *)(arg1)->readlines(arg2);
9087 wxPyEndAllowThreads(__tstate);
9088 if (PyErr_Occurred()) SWIG_fail;
9089 }
9090 resultobj = result;
9091 return resultobj;
9092 fail:
9093 return NULL;
9094 }
9095
9096
9097 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9098 PyObject *resultobj = 0;
9099 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9100 int arg2 ;
9101 int arg3 = (int) 0 ;
9102 void *argp1 = 0 ;
9103 int res1 = 0 ;
9104 int val2 ;
9105 int ecode2 = 0 ;
9106 int val3 ;
9107 int ecode3 = 0 ;
9108 PyObject * obj0 = 0 ;
9109 PyObject * obj1 = 0 ;
9110 PyObject * obj2 = 0 ;
9111 char * kwnames[] = {
9112 (char *) "self",(char *) "offset",(char *) "whence", NULL
9113 };
9114
9115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9117 if (!SWIG_IsOK(res1)) {
9118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9119 }
9120 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9121 ecode2 = SWIG_AsVal_int(obj1, &val2);
9122 if (!SWIG_IsOK(ecode2)) {
9123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9124 }
9125 arg2 = static_cast< int >(val2);
9126 if (obj2) {
9127 ecode3 = SWIG_AsVal_int(obj2, &val3);
9128 if (!SWIG_IsOK(ecode3)) {
9129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9130 }
9131 arg3 = static_cast< int >(val3);
9132 }
9133 {
9134 PyThreadState* __tstate = wxPyBeginAllowThreads();
9135 (arg1)->seek(arg2,arg3);
9136 wxPyEndAllowThreads(__tstate);
9137 if (PyErr_Occurred()) SWIG_fail;
9138 }
9139 resultobj = SWIG_Py_Void();
9140 return resultobj;
9141 fail:
9142 return NULL;
9143 }
9144
9145
9146 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9147 PyObject *resultobj = 0;
9148 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9149 int result;
9150 void *argp1 = 0 ;
9151 int res1 = 0 ;
9152 PyObject *swig_obj[1] ;
9153
9154 if (!args) SWIG_fail;
9155 swig_obj[0] = args;
9156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9157 if (!SWIG_IsOK(res1)) {
9158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9159 }
9160 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9161 {
9162 PyThreadState* __tstate = wxPyBeginAllowThreads();
9163 result = (int)(arg1)->tell();
9164 wxPyEndAllowThreads(__tstate);
9165 if (PyErr_Occurred()) SWIG_fail;
9166 }
9167 resultobj = SWIG_From_int(static_cast< int >(result));
9168 return resultobj;
9169 fail:
9170 return NULL;
9171 }
9172
9173
9174 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9175 PyObject *resultobj = 0;
9176 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9177 char result;
9178 void *argp1 = 0 ;
9179 int res1 = 0 ;
9180 PyObject *swig_obj[1] ;
9181
9182 if (!args) SWIG_fail;
9183 swig_obj[0] = args;
9184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9185 if (!SWIG_IsOK(res1)) {
9186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9187 }
9188 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9189 {
9190 PyThreadState* __tstate = wxPyBeginAllowThreads();
9191 result = (char)(arg1)->Peek();
9192 wxPyEndAllowThreads(__tstate);
9193 if (PyErr_Occurred()) SWIG_fail;
9194 }
9195 resultobj = SWIG_From_char(static_cast< char >(result));
9196 return resultobj;
9197 fail:
9198 return NULL;
9199 }
9200
9201
9202 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9203 PyObject *resultobj = 0;
9204 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9205 char result;
9206 void *argp1 = 0 ;
9207 int res1 = 0 ;
9208 PyObject *swig_obj[1] ;
9209
9210 if (!args) SWIG_fail;
9211 swig_obj[0] = args;
9212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9213 if (!SWIG_IsOK(res1)) {
9214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9215 }
9216 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9217 {
9218 PyThreadState* __tstate = wxPyBeginAllowThreads();
9219 result = (char)(arg1)->GetC();
9220 wxPyEndAllowThreads(__tstate);
9221 if (PyErr_Occurred()) SWIG_fail;
9222 }
9223 resultobj = SWIG_From_char(static_cast< char >(result));
9224 return resultobj;
9225 fail:
9226 return NULL;
9227 }
9228
9229
9230 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9231 PyObject *resultobj = 0;
9232 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9233 size_t result;
9234 void *argp1 = 0 ;
9235 int res1 = 0 ;
9236 PyObject *swig_obj[1] ;
9237
9238 if (!args) SWIG_fail;
9239 swig_obj[0] = args;
9240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9241 if (!SWIG_IsOK(res1)) {
9242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9243 }
9244 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9245 {
9246 PyThreadState* __tstate = wxPyBeginAllowThreads();
9247 result = (size_t)(arg1)->LastRead();
9248 wxPyEndAllowThreads(__tstate);
9249 if (PyErr_Occurred()) SWIG_fail;
9250 }
9251 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9252 return resultobj;
9253 fail:
9254 return NULL;
9255 }
9256
9257
9258 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9259 PyObject *resultobj = 0;
9260 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9261 bool result;
9262 void *argp1 = 0 ;
9263 int res1 = 0 ;
9264 PyObject *swig_obj[1] ;
9265
9266 if (!args) SWIG_fail;
9267 swig_obj[0] = args;
9268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9269 if (!SWIG_IsOK(res1)) {
9270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9271 }
9272 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9273 {
9274 PyThreadState* __tstate = wxPyBeginAllowThreads();
9275 result = (bool)(arg1)->CanRead();
9276 wxPyEndAllowThreads(__tstate);
9277 if (PyErr_Occurred()) SWIG_fail;
9278 }
9279 {
9280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9281 }
9282 return resultobj;
9283 fail:
9284 return NULL;
9285 }
9286
9287
9288 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9289 PyObject *resultobj = 0;
9290 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9291 bool result;
9292 void *argp1 = 0 ;
9293 int res1 = 0 ;
9294 PyObject *swig_obj[1] ;
9295
9296 if (!args) SWIG_fail;
9297 swig_obj[0] = args;
9298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9299 if (!SWIG_IsOK(res1)) {
9300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9301 }
9302 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9303 {
9304 PyThreadState* __tstate = wxPyBeginAllowThreads();
9305 result = (bool)(arg1)->Eof();
9306 wxPyEndAllowThreads(__tstate);
9307 if (PyErr_Occurred()) SWIG_fail;
9308 }
9309 {
9310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9311 }
9312 return resultobj;
9313 fail:
9314 return NULL;
9315 }
9316
9317
9318 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9319 PyObject *resultobj = 0;
9320 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9321 char arg2 ;
9322 bool result;
9323 void *argp1 = 0 ;
9324 int res1 = 0 ;
9325 char val2 ;
9326 int ecode2 = 0 ;
9327 PyObject * obj0 = 0 ;
9328 PyObject * obj1 = 0 ;
9329 char * kwnames[] = {
9330 (char *) "self",(char *) "c", NULL
9331 };
9332
9333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9335 if (!SWIG_IsOK(res1)) {
9336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9337 }
9338 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9339 ecode2 = SWIG_AsVal_char(obj1, &val2);
9340 if (!SWIG_IsOK(ecode2)) {
9341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9342 }
9343 arg2 = static_cast< char >(val2);
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 result = (bool)(arg1)->Ungetch(arg2);
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 {
9351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9352 }
9353 return resultobj;
9354 fail:
9355 return NULL;
9356 }
9357
9358
9359 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9360 PyObject *resultobj = 0;
9361 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9362 long arg2 ;
9363 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9364 long result;
9365 void *argp1 = 0 ;
9366 int res1 = 0 ;
9367 long val2 ;
9368 int ecode2 = 0 ;
9369 int val3 ;
9370 int ecode3 = 0 ;
9371 PyObject * obj0 = 0 ;
9372 PyObject * obj1 = 0 ;
9373 PyObject * obj2 = 0 ;
9374 char * kwnames[] = {
9375 (char *) "self",(char *) "pos",(char *) "mode", NULL
9376 };
9377
9378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9380 if (!SWIG_IsOK(res1)) {
9381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9382 }
9383 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9384 ecode2 = SWIG_AsVal_long(obj1, &val2);
9385 if (!SWIG_IsOK(ecode2)) {
9386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9387 }
9388 arg2 = static_cast< long >(val2);
9389 if (obj2) {
9390 ecode3 = SWIG_AsVal_int(obj2, &val3);
9391 if (!SWIG_IsOK(ecode3)) {
9392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9393 }
9394 arg3 = static_cast< wxSeekMode >(val3);
9395 }
9396 {
9397 PyThreadState* __tstate = wxPyBeginAllowThreads();
9398 result = (long)(arg1)->SeekI(arg2,arg3);
9399 wxPyEndAllowThreads(__tstate);
9400 if (PyErr_Occurred()) SWIG_fail;
9401 }
9402 resultobj = SWIG_From_long(static_cast< long >(result));
9403 return resultobj;
9404 fail:
9405 return NULL;
9406 }
9407
9408
9409 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9410 PyObject *resultobj = 0;
9411 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9412 long result;
9413 void *argp1 = 0 ;
9414 int res1 = 0 ;
9415 PyObject *swig_obj[1] ;
9416
9417 if (!args) SWIG_fail;
9418 swig_obj[0] = args;
9419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9420 if (!SWIG_IsOK(res1)) {
9421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9422 }
9423 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9424 {
9425 PyThreadState* __tstate = wxPyBeginAllowThreads();
9426 result = (long)(arg1)->TellI();
9427 wxPyEndAllowThreads(__tstate);
9428 if (PyErr_Occurred()) SWIG_fail;
9429 }
9430 resultobj = SWIG_From_long(static_cast< long >(result));
9431 return resultobj;
9432 fail:
9433 return NULL;
9434 }
9435
9436
9437 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9438 PyObject *obj;
9439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9440 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9441 return SWIG_Py_Void();
9442 }
9443
9444 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9445 return SWIG_Python_InitShadowInstance(args);
9446 }
9447
9448 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9449 PyObject *resultobj = 0;
9450 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9451 PyObject *arg2 = (PyObject *) 0 ;
9452 void *argp1 = 0 ;
9453 int res1 = 0 ;
9454 PyObject * obj0 = 0 ;
9455 PyObject * obj1 = 0 ;
9456 char * kwnames[] = {
9457 (char *) "self",(char *) "obj", NULL
9458 };
9459
9460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9462 if (!SWIG_IsOK(res1)) {
9463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9464 }
9465 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9466 arg2 = obj1;
9467 {
9468 PyThreadState* __tstate = wxPyBeginAllowThreads();
9469 wxOutputStream_write(arg1,arg2);
9470 wxPyEndAllowThreads(__tstate);
9471 if (PyErr_Occurred()) SWIG_fail;
9472 }
9473 resultobj = SWIG_Py_Void();
9474 return resultobj;
9475 fail:
9476 return NULL;
9477 }
9478
9479
9480 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9481 PyObject *resultobj = 0;
9482 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9483 size_t result;
9484 void *argp1 = 0 ;
9485 int res1 = 0 ;
9486 PyObject *swig_obj[1] ;
9487
9488 if (!args) SWIG_fail;
9489 swig_obj[0] = args;
9490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9491 if (!SWIG_IsOK(res1)) {
9492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9493 }
9494 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9495 {
9496 PyThreadState* __tstate = wxPyBeginAllowThreads();
9497 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9498 wxPyEndAllowThreads(__tstate);
9499 if (PyErr_Occurred()) SWIG_fail;
9500 }
9501 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9502 return resultobj;
9503 fail:
9504 return NULL;
9505 }
9506
9507
9508 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9509 PyObject *obj;
9510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9511 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9512 return SWIG_Py_Void();
9513 }
9514
9515 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9516 PyObject *resultobj = 0;
9517 wxInputStream *arg1 = (wxInputStream *) 0 ;
9518 wxString *arg2 = 0 ;
9519 wxString *arg3 = 0 ;
9520 wxString *arg4 = 0 ;
9521 wxDateTime arg5 ;
9522 wxFSFile *result = 0 ;
9523 wxPyInputStream *temp1 ;
9524 bool temp2 = false ;
9525 bool temp3 = false ;
9526 bool temp4 = false ;
9527 void *argp5 ;
9528 int res5 = 0 ;
9529 PyObject * obj0 = 0 ;
9530 PyObject * obj1 = 0 ;
9531 PyObject * obj2 = 0 ;
9532 PyObject * obj3 = 0 ;
9533 PyObject * obj4 = 0 ;
9534 char * kwnames[] = {
9535 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9536 };
9537
9538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9539 {
9540 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9541 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9542 } else {
9543 PyErr_Clear(); // clear the failure of the wxPyConvert above
9544 arg1 = wxPyCBInputStream_create(obj0, true);
9545 if (arg1 == NULL) {
9546 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9547 SWIG_fail;
9548 }
9549 }
9550 }
9551 {
9552 arg2 = wxString_in_helper(obj1);
9553 if (arg2 == NULL) SWIG_fail;
9554 temp2 = true;
9555 }
9556 {
9557 arg3 = wxString_in_helper(obj2);
9558 if (arg3 == NULL) SWIG_fail;
9559 temp3 = true;
9560 }
9561 {
9562 arg4 = wxString_in_helper(obj3);
9563 if (arg4 == NULL) SWIG_fail;
9564 temp4 = true;
9565 }
9566 {
9567 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9568 if (!SWIG_IsOK(res5)) {
9569 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9570 }
9571 if (!argp5) {
9572 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9573 } else {
9574 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9575 arg5 = *temp;
9576 if (SWIG_IsNewObj(res5)) delete temp;
9577 }
9578 }
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9582 wxPyEndAllowThreads(__tstate);
9583 if (PyErr_Occurred()) SWIG_fail;
9584 }
9585 {
9586 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9587 }
9588 {
9589 if (temp2)
9590 delete arg2;
9591 }
9592 {
9593 if (temp3)
9594 delete arg3;
9595 }
9596 {
9597 if (temp4)
9598 delete arg4;
9599 }
9600 return resultobj;
9601 fail:
9602 {
9603 if (temp2)
9604 delete arg2;
9605 }
9606 {
9607 if (temp3)
9608 delete arg3;
9609 }
9610 {
9611 if (temp4)
9612 delete arg4;
9613 }
9614 return NULL;
9615 }
9616
9617
9618 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9619 PyObject *resultobj = 0;
9620 wxFSFile *arg1 = (wxFSFile *) 0 ;
9621 void *argp1 = 0 ;
9622 int res1 = 0 ;
9623 PyObject *swig_obj[1] ;
9624
9625 if (!args) SWIG_fail;
9626 swig_obj[0] = args;
9627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9628 if (!SWIG_IsOK(res1)) {
9629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9630 }
9631 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9632 {
9633 PyThreadState* __tstate = wxPyBeginAllowThreads();
9634 delete arg1;
9635
9636 wxPyEndAllowThreads(__tstate);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 resultobj = SWIG_Py_Void();
9640 return resultobj;
9641 fail:
9642 return NULL;
9643 }
9644
9645
9646 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9647 PyObject *resultobj = 0;
9648 wxFSFile *arg1 = (wxFSFile *) 0 ;
9649 wxInputStream *result = 0 ;
9650 void *argp1 = 0 ;
9651 int res1 = 0 ;
9652 PyObject *swig_obj[1] ;
9653
9654 if (!args) SWIG_fail;
9655 swig_obj[0] = args;
9656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9657 if (!SWIG_IsOK(res1)) {
9658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9659 }
9660 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9661 {
9662 PyThreadState* __tstate = wxPyBeginAllowThreads();
9663 result = (wxInputStream *)(arg1)->GetStream();
9664 wxPyEndAllowThreads(__tstate);
9665 if (PyErr_Occurred()) SWIG_fail;
9666 }
9667 {
9668 wxPyInputStream * _ptr = NULL;
9669
9670 if (result) {
9671 _ptr = new wxPyInputStream(result);
9672 }
9673 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9674 }
9675 return resultobj;
9676 fail:
9677 return NULL;
9678 }
9679
9680
9681 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9682 PyObject *resultobj = 0;
9683 wxFSFile *arg1 = (wxFSFile *) 0 ;
9684 wxString *result = 0 ;
9685 void *argp1 = 0 ;
9686 int res1 = 0 ;
9687 PyObject *swig_obj[1] ;
9688
9689 if (!args) SWIG_fail;
9690 swig_obj[0] = args;
9691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9692 if (!SWIG_IsOK(res1)) {
9693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9694 }
9695 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9696 {
9697 PyThreadState* __tstate = wxPyBeginAllowThreads();
9698 {
9699 wxString const &_result_ref = (arg1)->GetMimeType();
9700 result = (wxString *) &_result_ref;
9701 }
9702 wxPyEndAllowThreads(__tstate);
9703 if (PyErr_Occurred()) SWIG_fail;
9704 }
9705 {
9706 #if wxUSE_UNICODE
9707 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9708 #else
9709 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9710 #endif
9711 }
9712 return resultobj;
9713 fail:
9714 return NULL;
9715 }
9716
9717
9718 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9719 PyObject *resultobj = 0;
9720 wxFSFile *arg1 = (wxFSFile *) 0 ;
9721 wxString *result = 0 ;
9722 void *argp1 = 0 ;
9723 int res1 = 0 ;
9724 PyObject *swig_obj[1] ;
9725
9726 if (!args) SWIG_fail;
9727 swig_obj[0] = args;
9728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9729 if (!SWIG_IsOK(res1)) {
9730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9731 }
9732 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9733 {
9734 PyThreadState* __tstate = wxPyBeginAllowThreads();
9735 {
9736 wxString const &_result_ref = (arg1)->GetLocation();
9737 result = (wxString *) &_result_ref;
9738 }
9739 wxPyEndAllowThreads(__tstate);
9740 if (PyErr_Occurred()) SWIG_fail;
9741 }
9742 {
9743 #if wxUSE_UNICODE
9744 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9745 #else
9746 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9747 #endif
9748 }
9749 return resultobj;
9750 fail:
9751 return NULL;
9752 }
9753
9754
9755 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9756 PyObject *resultobj = 0;
9757 wxFSFile *arg1 = (wxFSFile *) 0 ;
9758 wxString *result = 0 ;
9759 void *argp1 = 0 ;
9760 int res1 = 0 ;
9761 PyObject *swig_obj[1] ;
9762
9763 if (!args) SWIG_fail;
9764 swig_obj[0] = args;
9765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9766 if (!SWIG_IsOK(res1)) {
9767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9768 }
9769 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9770 {
9771 PyThreadState* __tstate = wxPyBeginAllowThreads();
9772 {
9773 wxString const &_result_ref = (arg1)->GetAnchor();
9774 result = (wxString *) &_result_ref;
9775 }
9776 wxPyEndAllowThreads(__tstate);
9777 if (PyErr_Occurred()) SWIG_fail;
9778 }
9779 {
9780 #if wxUSE_UNICODE
9781 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9782 #else
9783 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9784 #endif
9785 }
9786 return resultobj;
9787 fail:
9788 return NULL;
9789 }
9790
9791
9792 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9793 PyObject *resultobj = 0;
9794 wxFSFile *arg1 = (wxFSFile *) 0 ;
9795 wxDateTime result;
9796 void *argp1 = 0 ;
9797 int res1 = 0 ;
9798 PyObject *swig_obj[1] ;
9799
9800 if (!args) SWIG_fail;
9801 swig_obj[0] = args;
9802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9803 if (!SWIG_IsOK(res1)) {
9804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9805 }
9806 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9807 {
9808 PyThreadState* __tstate = wxPyBeginAllowThreads();
9809 result = (arg1)->GetModificationTime();
9810 wxPyEndAllowThreads(__tstate);
9811 if (PyErr_Occurred()) SWIG_fail;
9812 }
9813 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9814 return resultobj;
9815 fail:
9816 return NULL;
9817 }
9818
9819
9820 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9821 PyObject *obj;
9822 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9823 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9824 return SWIG_Py_Void();
9825 }
9826
9827 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9828 return SWIG_Python_InitShadowInstance(args);
9829 }
9830
9831 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9832 PyObject *resultobj = 0;
9833 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9834 void *argp1 = 0 ;
9835 int res1 = 0 ;
9836 PyObject *swig_obj[1] ;
9837
9838 if (!args) SWIG_fail;
9839 swig_obj[0] = args;
9840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9841 if (!SWIG_IsOK(res1)) {
9842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9843 }
9844 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9845 {
9846 PyThreadState* __tstate = wxPyBeginAllowThreads();
9847 delete arg1;
9848
9849 wxPyEndAllowThreads(__tstate);
9850 if (PyErr_Occurred()) SWIG_fail;
9851 }
9852 resultobj = SWIG_Py_Void();
9853 return resultobj;
9854 fail:
9855 return NULL;
9856 }
9857
9858
9859 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9860 PyObject *obj;
9861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9862 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9863 return SWIG_Py_Void();
9864 }
9865
9866 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9867 PyObject *resultobj = 0;
9868 wxPyFileSystemHandler *result = 0 ;
9869
9870 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9871 {
9872 PyThreadState* __tstate = wxPyBeginAllowThreads();
9873 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9874 wxPyEndAllowThreads(__tstate);
9875 if (PyErr_Occurred()) SWIG_fail;
9876 }
9877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9878 return resultobj;
9879 fail:
9880 return NULL;
9881 }
9882
9883
9884 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9885 PyObject *resultobj = 0;
9886 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9887 PyObject *arg2 = (PyObject *) 0 ;
9888 PyObject *arg3 = (PyObject *) 0 ;
9889 void *argp1 = 0 ;
9890 int res1 = 0 ;
9891 PyObject * obj0 = 0 ;
9892 PyObject * obj1 = 0 ;
9893 PyObject * obj2 = 0 ;
9894 char * kwnames[] = {
9895 (char *) "self",(char *) "self",(char *) "_class", NULL
9896 };
9897
9898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9900 if (!SWIG_IsOK(res1)) {
9901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9902 }
9903 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9904 arg2 = obj1;
9905 arg3 = obj2;
9906 {
9907 PyThreadState* __tstate = wxPyBeginAllowThreads();
9908 (arg1)->_setCallbackInfo(arg2,arg3);
9909 wxPyEndAllowThreads(__tstate);
9910 if (PyErr_Occurred()) SWIG_fail;
9911 }
9912 resultobj = SWIG_Py_Void();
9913 return resultobj;
9914 fail:
9915 return NULL;
9916 }
9917
9918
9919 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9920 PyObject *resultobj = 0;
9921 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9922 wxString *arg2 = 0 ;
9923 bool result;
9924 void *argp1 = 0 ;
9925 int res1 = 0 ;
9926 bool temp2 = false ;
9927 PyObject * obj0 = 0 ;
9928 PyObject * obj1 = 0 ;
9929 char * kwnames[] = {
9930 (char *) "self",(char *) "location", NULL
9931 };
9932
9933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9935 if (!SWIG_IsOK(res1)) {
9936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9937 }
9938 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9939 {
9940 arg2 = wxString_in_helper(obj1);
9941 if (arg2 == NULL) SWIG_fail;
9942 temp2 = true;
9943 }
9944 {
9945 PyThreadState* __tstate = wxPyBeginAllowThreads();
9946 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9947 wxPyEndAllowThreads(__tstate);
9948 if (PyErr_Occurred()) SWIG_fail;
9949 }
9950 {
9951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9952 }
9953 {
9954 if (temp2)
9955 delete arg2;
9956 }
9957 return resultobj;
9958 fail:
9959 {
9960 if (temp2)
9961 delete arg2;
9962 }
9963 return NULL;
9964 }
9965
9966
9967 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9968 PyObject *resultobj = 0;
9969 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9970 wxFileSystem *arg2 = 0 ;
9971 wxString *arg3 = 0 ;
9972 wxFSFile *result = 0 ;
9973 void *argp1 = 0 ;
9974 int res1 = 0 ;
9975 void *argp2 = 0 ;
9976 int res2 = 0 ;
9977 bool temp3 = false ;
9978 PyObject * obj0 = 0 ;
9979 PyObject * obj1 = 0 ;
9980 PyObject * obj2 = 0 ;
9981 char * kwnames[] = {
9982 (char *) "self",(char *) "fs",(char *) "location", NULL
9983 };
9984
9985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) 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_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9989 }
9990 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9991 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
9992 if (!SWIG_IsOK(res2)) {
9993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9994 }
9995 if (!argp2) {
9996 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9997 }
9998 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
9999 {
10000 arg3 = wxString_in_helper(obj2);
10001 if (arg3 == NULL) SWIG_fail;
10002 temp3 = true;
10003 }
10004 {
10005 PyThreadState* __tstate = wxPyBeginAllowThreads();
10006 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10007 wxPyEndAllowThreads(__tstate);
10008 if (PyErr_Occurred()) SWIG_fail;
10009 }
10010 {
10011 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10012 }
10013 {
10014 if (temp3)
10015 delete arg3;
10016 }
10017 return resultobj;
10018 fail:
10019 {
10020 if (temp3)
10021 delete arg3;
10022 }
10023 return NULL;
10024 }
10025
10026
10027 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10028 PyObject *resultobj = 0;
10029 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10030 wxString *arg2 = 0 ;
10031 int arg3 = (int) 0 ;
10032 wxString result;
10033 void *argp1 = 0 ;
10034 int res1 = 0 ;
10035 bool temp2 = false ;
10036 int val3 ;
10037 int ecode3 = 0 ;
10038 PyObject * obj0 = 0 ;
10039 PyObject * obj1 = 0 ;
10040 PyObject * obj2 = 0 ;
10041 char * kwnames[] = {
10042 (char *) "self",(char *) "spec",(char *) "flags", NULL
10043 };
10044
10045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10047 if (!SWIG_IsOK(res1)) {
10048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10049 }
10050 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10051 {
10052 arg2 = wxString_in_helper(obj1);
10053 if (arg2 == NULL) SWIG_fail;
10054 temp2 = true;
10055 }
10056 if (obj2) {
10057 ecode3 = SWIG_AsVal_int(obj2, &val3);
10058 if (!SWIG_IsOK(ecode3)) {
10059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10060 }
10061 arg3 = static_cast< int >(val3);
10062 }
10063 {
10064 PyThreadState* __tstate = wxPyBeginAllowThreads();
10065 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10066 wxPyEndAllowThreads(__tstate);
10067 if (PyErr_Occurred()) SWIG_fail;
10068 }
10069 {
10070 #if wxUSE_UNICODE
10071 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10072 #else
10073 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10074 #endif
10075 }
10076 {
10077 if (temp2)
10078 delete arg2;
10079 }
10080 return resultobj;
10081 fail:
10082 {
10083 if (temp2)
10084 delete arg2;
10085 }
10086 return NULL;
10087 }
10088
10089
10090 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10091 PyObject *resultobj = 0;
10092 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10093 wxString result;
10094 void *argp1 = 0 ;
10095 int res1 = 0 ;
10096 PyObject *swig_obj[1] ;
10097
10098 if (!args) SWIG_fail;
10099 swig_obj[0] = args;
10100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10101 if (!SWIG_IsOK(res1)) {
10102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10103 }
10104 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10105 {
10106 PyThreadState* __tstate = wxPyBeginAllowThreads();
10107 result = (arg1)->FindNext();
10108 wxPyEndAllowThreads(__tstate);
10109 if (PyErr_Occurred()) SWIG_fail;
10110 }
10111 {
10112 #if wxUSE_UNICODE
10113 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10114 #else
10115 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10116 #endif
10117 }
10118 return resultobj;
10119 fail:
10120 return NULL;
10121 }
10122
10123
10124 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10125 PyObject *resultobj = 0;
10126 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10127 wxString *arg2 = 0 ;
10128 wxString result;
10129 void *argp1 = 0 ;
10130 int res1 = 0 ;
10131 bool temp2 = false ;
10132 PyObject * obj0 = 0 ;
10133 PyObject * obj1 = 0 ;
10134 char * kwnames[] = {
10135 (char *) "self",(char *) "location", NULL
10136 };
10137
10138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10140 if (!SWIG_IsOK(res1)) {
10141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10142 }
10143 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10144 {
10145 arg2 = wxString_in_helper(obj1);
10146 if (arg2 == NULL) SWIG_fail;
10147 temp2 = true;
10148 }
10149 {
10150 PyThreadState* __tstate = wxPyBeginAllowThreads();
10151 result = (arg1)->GetProtocol((wxString const &)*arg2);
10152 wxPyEndAllowThreads(__tstate);
10153 if (PyErr_Occurred()) SWIG_fail;
10154 }
10155 {
10156 #if wxUSE_UNICODE
10157 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10158 #else
10159 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10160 #endif
10161 }
10162 {
10163 if (temp2)
10164 delete arg2;
10165 }
10166 return resultobj;
10167 fail:
10168 {
10169 if (temp2)
10170 delete arg2;
10171 }
10172 return NULL;
10173 }
10174
10175
10176 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(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_GetLeftLocation",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_GetLeftLocation" "', 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)->GetLeftLocation((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_GetAnchor(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_GetAnchor",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_GetAnchor" "', 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)->GetAnchor((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_GetRightLocation(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_GetRightLocation",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_GetRightLocation" "', 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)->GetRightLocation((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_GetMimeTypeFromExt(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_GetMimeTypeFromExt",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_GetMimeTypeFromExt" "', 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)->GetMimeTypeFromExt((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 *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10385 PyObject *obj;
10386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10387 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10388 return SWIG_Py_Void();
10389 }
10390
10391 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10392 return SWIG_Python_InitShadowInstance(args);
10393 }
10394
10395 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10396 PyObject *resultobj = 0;
10397 wxFileSystem *result = 0 ;
10398
10399 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10400 {
10401 PyThreadState* __tstate = wxPyBeginAllowThreads();
10402 result = (wxFileSystem *)new wxFileSystem();
10403 wxPyEndAllowThreads(__tstate);
10404 if (PyErr_Occurred()) SWIG_fail;
10405 }
10406 {
10407 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10408 }
10409 return resultobj;
10410 fail:
10411 return NULL;
10412 }
10413
10414
10415 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10416 PyObject *resultobj = 0;
10417 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10418 void *argp1 = 0 ;
10419 int res1 = 0 ;
10420 PyObject *swig_obj[1] ;
10421
10422 if (!args) SWIG_fail;
10423 swig_obj[0] = args;
10424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10425 if (!SWIG_IsOK(res1)) {
10426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10427 }
10428 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10429 {
10430 PyThreadState* __tstate = wxPyBeginAllowThreads();
10431 delete arg1;
10432
10433 wxPyEndAllowThreads(__tstate);
10434 if (PyErr_Occurred()) SWIG_fail;
10435 }
10436 resultobj = SWIG_Py_Void();
10437 return resultobj;
10438 fail:
10439 return NULL;
10440 }
10441
10442
10443 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10444 PyObject *resultobj = 0;
10445 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10446 wxString *arg2 = 0 ;
10447 bool arg3 = (bool) false ;
10448 void *argp1 = 0 ;
10449 int res1 = 0 ;
10450 bool temp2 = false ;
10451 bool val3 ;
10452 int ecode3 = 0 ;
10453 PyObject * obj0 = 0 ;
10454 PyObject * obj1 = 0 ;
10455 PyObject * obj2 = 0 ;
10456 char * kwnames[] = {
10457 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10458 };
10459
10460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10462 if (!SWIG_IsOK(res1)) {
10463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10464 }
10465 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10466 {
10467 arg2 = wxString_in_helper(obj1);
10468 if (arg2 == NULL) SWIG_fail;
10469 temp2 = true;
10470 }
10471 if (obj2) {
10472 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10473 if (!SWIG_IsOK(ecode3)) {
10474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10475 }
10476 arg3 = static_cast< bool >(val3);
10477 }
10478 {
10479 PyThreadState* __tstate = wxPyBeginAllowThreads();
10480 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10481 wxPyEndAllowThreads(__tstate);
10482 if (PyErr_Occurred()) SWIG_fail;
10483 }
10484 resultobj = SWIG_Py_Void();
10485 {
10486 if (temp2)
10487 delete arg2;
10488 }
10489 return resultobj;
10490 fail:
10491 {
10492 if (temp2)
10493 delete arg2;
10494 }
10495 return NULL;
10496 }
10497
10498
10499 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10500 PyObject *resultobj = 0;
10501 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10502 wxString result;
10503 void *argp1 = 0 ;
10504 int res1 = 0 ;
10505 PyObject *swig_obj[1] ;
10506
10507 if (!args) SWIG_fail;
10508 swig_obj[0] = args;
10509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10510 if (!SWIG_IsOK(res1)) {
10511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10512 }
10513 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10514 {
10515 PyThreadState* __tstate = wxPyBeginAllowThreads();
10516 result = (arg1)->GetPath();
10517 wxPyEndAllowThreads(__tstate);
10518 if (PyErr_Occurred()) SWIG_fail;
10519 }
10520 {
10521 #if wxUSE_UNICODE
10522 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10523 #else
10524 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10525 #endif
10526 }
10527 return resultobj;
10528 fail:
10529 return NULL;
10530 }
10531
10532
10533 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10534 PyObject *resultobj = 0;
10535 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10536 wxString *arg2 = 0 ;
10537 wxFSFile *result = 0 ;
10538 void *argp1 = 0 ;
10539 int res1 = 0 ;
10540 bool temp2 = false ;
10541 PyObject * obj0 = 0 ;
10542 PyObject * obj1 = 0 ;
10543 char * kwnames[] = {
10544 (char *) "self",(char *) "location", NULL
10545 };
10546
10547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10549 if (!SWIG_IsOK(res1)) {
10550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10551 }
10552 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10553 {
10554 arg2 = wxString_in_helper(obj1);
10555 if (arg2 == NULL) SWIG_fail;
10556 temp2 = true;
10557 }
10558 {
10559 PyThreadState* __tstate = wxPyBeginAllowThreads();
10560 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10561 wxPyEndAllowThreads(__tstate);
10562 if (PyErr_Occurred()) SWIG_fail;
10563 }
10564 {
10565 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10566 }
10567 {
10568 if (temp2)
10569 delete arg2;
10570 }
10571 return resultobj;
10572 fail:
10573 {
10574 if (temp2)
10575 delete arg2;
10576 }
10577 return NULL;
10578 }
10579
10580
10581 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10582 PyObject *resultobj = 0;
10583 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10584 wxString *arg2 = 0 ;
10585 int arg3 = (int) 0 ;
10586 wxString result;
10587 void *argp1 = 0 ;
10588 int res1 = 0 ;
10589 bool temp2 = false ;
10590 int val3 ;
10591 int ecode3 = 0 ;
10592 PyObject * obj0 = 0 ;
10593 PyObject * obj1 = 0 ;
10594 PyObject * obj2 = 0 ;
10595 char * kwnames[] = {
10596 (char *) "self",(char *) "spec",(char *) "flags", NULL
10597 };
10598
10599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) 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_FindFirst" "', 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 if (obj2) {
10611 ecode3 = SWIG_AsVal_int(obj2, &val3);
10612 if (!SWIG_IsOK(ecode3)) {
10613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10614 }
10615 arg3 = static_cast< int >(val3);
10616 }
10617 {
10618 PyThreadState* __tstate = wxPyBeginAllowThreads();
10619 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10620 wxPyEndAllowThreads(__tstate);
10621 if (PyErr_Occurred()) SWIG_fail;
10622 }
10623 {
10624 #if wxUSE_UNICODE
10625 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10626 #else
10627 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10628 #endif
10629 }
10630 {
10631 if (temp2)
10632 delete arg2;
10633 }
10634 return resultobj;
10635 fail:
10636 {
10637 if (temp2)
10638 delete arg2;
10639 }
10640 return NULL;
10641 }
10642
10643
10644 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10645 PyObject *resultobj = 0;
10646 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10647 wxString result;
10648 void *argp1 = 0 ;
10649 int res1 = 0 ;
10650 PyObject *swig_obj[1] ;
10651
10652 if (!args) SWIG_fail;
10653 swig_obj[0] = args;
10654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10655 if (!SWIG_IsOK(res1)) {
10656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10657 }
10658 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10659 {
10660 PyThreadState* __tstate = wxPyBeginAllowThreads();
10661 result = (arg1)->FindNext();
10662 wxPyEndAllowThreads(__tstate);
10663 if (PyErr_Occurred()) SWIG_fail;
10664 }
10665 {
10666 #if wxUSE_UNICODE
10667 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10668 #else
10669 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10670 #endif
10671 }
10672 return resultobj;
10673 fail:
10674 return NULL;
10675 }
10676
10677
10678 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10679 PyObject *resultobj = 0;
10680 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10681 int res1 = 0 ;
10682 PyObject * obj0 = 0 ;
10683 char * kwnames[] = {
10684 (char *) "handler", NULL
10685 };
10686
10687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10688 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10689 if (!SWIG_IsOK(res1)) {
10690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10691 }
10692 {
10693 PyThreadState* __tstate = wxPyBeginAllowThreads();
10694 wxFileSystem::AddHandler(arg1);
10695 wxPyEndAllowThreads(__tstate);
10696 if (PyErr_Occurred()) SWIG_fail;
10697 }
10698 resultobj = SWIG_Py_Void();
10699 return resultobj;
10700 fail:
10701 return NULL;
10702 }
10703
10704
10705 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10706 PyObject *resultobj = 0;
10707
10708 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10709 {
10710 PyThreadState* __tstate = wxPyBeginAllowThreads();
10711 wxFileSystem::CleanUpHandlers();
10712 wxPyEndAllowThreads(__tstate);
10713 if (PyErr_Occurred()) SWIG_fail;
10714 }
10715 resultobj = SWIG_Py_Void();
10716 return resultobj;
10717 fail:
10718 return NULL;
10719 }
10720
10721
10722 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10723 PyObject *resultobj = 0;
10724 wxString *arg1 = 0 ;
10725 wxString result;
10726 bool temp1 = false ;
10727 PyObject * obj0 = 0 ;
10728 char * kwnames[] = {
10729 (char *) "filename", NULL
10730 };
10731
10732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10733 {
10734 arg1 = wxString_in_helper(obj0);
10735 if (arg1 == NULL) SWIG_fail;
10736 temp1 = true;
10737 }
10738 {
10739 PyThreadState* __tstate = wxPyBeginAllowThreads();
10740 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10741 wxPyEndAllowThreads(__tstate);
10742 if (PyErr_Occurred()) SWIG_fail;
10743 }
10744 {
10745 #if wxUSE_UNICODE
10746 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10747 #else
10748 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10749 #endif
10750 }
10751 {
10752 if (temp1)
10753 delete arg1;
10754 }
10755 return resultobj;
10756 fail:
10757 {
10758 if (temp1)
10759 delete arg1;
10760 }
10761 return NULL;
10762 }
10763
10764
10765 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10766 PyObject *resultobj = 0;
10767 wxString *arg1 = 0 ;
10768 wxString result;
10769 bool temp1 = false ;
10770 PyObject * obj0 = 0 ;
10771 char * kwnames[] = {
10772 (char *) "url", NULL
10773 };
10774
10775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10776 {
10777 arg1 = wxString_in_helper(obj0);
10778 if (arg1 == NULL) SWIG_fail;
10779 temp1 = true;
10780 }
10781 {
10782 PyThreadState* __tstate = wxPyBeginAllowThreads();
10783 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10784 wxPyEndAllowThreads(__tstate);
10785 if (PyErr_Occurred()) SWIG_fail;
10786 }
10787 {
10788 #if wxUSE_UNICODE
10789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10790 #else
10791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10792 #endif
10793 }
10794 {
10795 if (temp1)
10796 delete arg1;
10797 }
10798 return resultobj;
10799 fail:
10800 {
10801 if (temp1)
10802 delete arg1;
10803 }
10804 return NULL;
10805 }
10806
10807
10808 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10809 PyObject *obj;
10810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10811 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10812 return SWIG_Py_Void();
10813 }
10814
10815 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10816 return SWIG_Python_InitShadowInstance(args);
10817 }
10818
10819 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10820 PyObject *resultobj = 0;
10821 wxInternetFSHandler *result = 0 ;
10822
10823 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10824 {
10825 PyThreadState* __tstate = wxPyBeginAllowThreads();
10826 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10827 wxPyEndAllowThreads(__tstate);
10828 if (PyErr_Occurred()) SWIG_fail;
10829 }
10830 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10831 return resultobj;
10832 fail:
10833 return NULL;
10834 }
10835
10836
10837 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10838 PyObject *resultobj = 0;
10839 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10840 wxString *arg2 = 0 ;
10841 bool result;
10842 void *argp1 = 0 ;
10843 int res1 = 0 ;
10844 bool temp2 = false ;
10845 PyObject * obj0 = 0 ;
10846 PyObject * obj1 = 0 ;
10847 char * kwnames[] = {
10848 (char *) "self",(char *) "location", NULL
10849 };
10850
10851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10853 if (!SWIG_IsOK(res1)) {
10854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10855 }
10856 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10857 {
10858 arg2 = wxString_in_helper(obj1);
10859 if (arg2 == NULL) SWIG_fail;
10860 temp2 = true;
10861 }
10862 {
10863 PyThreadState* __tstate = wxPyBeginAllowThreads();
10864 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10865 wxPyEndAllowThreads(__tstate);
10866 if (PyErr_Occurred()) SWIG_fail;
10867 }
10868 {
10869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10870 }
10871 {
10872 if (temp2)
10873 delete arg2;
10874 }
10875 return resultobj;
10876 fail:
10877 {
10878 if (temp2)
10879 delete arg2;
10880 }
10881 return NULL;
10882 }
10883
10884
10885 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10886 PyObject *resultobj = 0;
10887 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10888 wxFileSystem *arg2 = 0 ;
10889 wxString *arg3 = 0 ;
10890 wxFSFile *result = 0 ;
10891 void *argp1 = 0 ;
10892 int res1 = 0 ;
10893 void *argp2 = 0 ;
10894 int res2 = 0 ;
10895 bool temp3 = false ;
10896 PyObject * obj0 = 0 ;
10897 PyObject * obj1 = 0 ;
10898 PyObject * obj2 = 0 ;
10899 char * kwnames[] = {
10900 (char *) "self",(char *) "fs",(char *) "location", NULL
10901 };
10902
10903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) 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_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10907 }
10908 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10909 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10910 if (!SWIG_IsOK(res2)) {
10911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10912 }
10913 if (!argp2) {
10914 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10915 }
10916 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10917 {
10918 arg3 = wxString_in_helper(obj2);
10919 if (arg3 == NULL) SWIG_fail;
10920 temp3 = true;
10921 }
10922 {
10923 PyThreadState* __tstate = wxPyBeginAllowThreads();
10924 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10925 wxPyEndAllowThreads(__tstate);
10926 if (PyErr_Occurred()) SWIG_fail;
10927 }
10928 {
10929 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10930 }
10931 {
10932 if (temp3)
10933 delete arg3;
10934 }
10935 return resultobj;
10936 fail:
10937 {
10938 if (temp3)
10939 delete arg3;
10940 }
10941 return NULL;
10942 }
10943
10944
10945 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10946 PyObject *obj;
10947 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10948 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
10949 return SWIG_Py_Void();
10950 }
10951
10952 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10953 return SWIG_Python_InitShadowInstance(args);
10954 }
10955
10956 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10957 PyObject *resultobj = 0;
10958 wxZipFSHandler *result = 0 ;
10959
10960 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
10961 {
10962 PyThreadState* __tstate = wxPyBeginAllowThreads();
10963 result = (wxZipFSHandler *)new wxZipFSHandler();
10964 wxPyEndAllowThreads(__tstate);
10965 if (PyErr_Occurred()) SWIG_fail;
10966 }
10967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
10968 return resultobj;
10969 fail:
10970 return NULL;
10971 }
10972
10973
10974 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10975 PyObject *resultobj = 0;
10976 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
10977 wxString *arg2 = 0 ;
10978 bool result;
10979 void *argp1 = 0 ;
10980 int res1 = 0 ;
10981 bool temp2 = false ;
10982 PyObject * obj0 = 0 ;
10983 PyObject * obj1 = 0 ;
10984 char * kwnames[] = {
10985 (char *) "self",(char *) "location", NULL
10986 };
10987
10988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
10990 if (!SWIG_IsOK(res1)) {
10991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
10992 }
10993 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
10994 {
10995 arg2 = wxString_in_helper(obj1);
10996 if (arg2 == NULL) SWIG_fail;
10997 temp2 = true;
10998 }
10999 {
11000 PyThreadState* __tstate = wxPyBeginAllowThreads();
11001 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11002 wxPyEndAllowThreads(__tstate);
11003 if (PyErr_Occurred()) SWIG_fail;
11004 }
11005 {
11006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11007 }
11008 {
11009 if (temp2)
11010 delete arg2;
11011 }
11012 return resultobj;
11013 fail:
11014 {
11015 if (temp2)
11016 delete arg2;
11017 }
11018 return NULL;
11019 }
11020
11021
11022 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11023 PyObject *resultobj = 0;
11024 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11025 wxFileSystem *arg2 = 0 ;
11026 wxString *arg3 = 0 ;
11027 wxFSFile *result = 0 ;
11028 void *argp1 = 0 ;
11029 int res1 = 0 ;
11030 void *argp2 = 0 ;
11031 int res2 = 0 ;
11032 bool temp3 = false ;
11033 PyObject * obj0 = 0 ;
11034 PyObject * obj1 = 0 ;
11035 PyObject * obj2 = 0 ;
11036 char * kwnames[] = {
11037 (char *) "self",(char *) "fs",(char *) "location", NULL
11038 };
11039
11040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) 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_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11044 }
11045 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11046 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11047 if (!SWIG_IsOK(res2)) {
11048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11049 }
11050 if (!argp2) {
11051 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11052 }
11053 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11054 {
11055 arg3 = wxString_in_helper(obj2);
11056 if (arg3 == NULL) SWIG_fail;
11057 temp3 = true;
11058 }
11059 {
11060 PyThreadState* __tstate = wxPyBeginAllowThreads();
11061 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11062 wxPyEndAllowThreads(__tstate);
11063 if (PyErr_Occurred()) SWIG_fail;
11064 }
11065 {
11066 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11067 }
11068 {
11069 if (temp3)
11070 delete arg3;
11071 }
11072 return resultobj;
11073 fail:
11074 {
11075 if (temp3)
11076 delete arg3;
11077 }
11078 return NULL;
11079 }
11080
11081
11082 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11083 PyObject *resultobj = 0;
11084 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11085 wxString *arg2 = 0 ;
11086 int arg3 = (int) 0 ;
11087 wxString result;
11088 void *argp1 = 0 ;
11089 int res1 = 0 ;
11090 bool temp2 = false ;
11091 int val3 ;
11092 int ecode3 = 0 ;
11093 PyObject * obj0 = 0 ;
11094 PyObject * obj1 = 0 ;
11095 PyObject * obj2 = 0 ;
11096 char * kwnames[] = {
11097 (char *) "self",(char *) "spec",(char *) "flags", NULL
11098 };
11099
11100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11102 if (!SWIG_IsOK(res1)) {
11103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11104 }
11105 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11106 {
11107 arg2 = wxString_in_helper(obj1);
11108 if (arg2 == NULL) SWIG_fail;
11109 temp2 = true;
11110 }
11111 if (obj2) {
11112 ecode3 = SWIG_AsVal_int(obj2, &val3);
11113 if (!SWIG_IsOK(ecode3)) {
11114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11115 }
11116 arg3 = static_cast< int >(val3);
11117 }
11118 {
11119 PyThreadState* __tstate = wxPyBeginAllowThreads();
11120 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11121 wxPyEndAllowThreads(__tstate);
11122 if (PyErr_Occurred()) SWIG_fail;
11123 }
11124 {
11125 #if wxUSE_UNICODE
11126 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11127 #else
11128 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11129 #endif
11130 }
11131 {
11132 if (temp2)
11133 delete arg2;
11134 }
11135 return resultobj;
11136 fail:
11137 {
11138 if (temp2)
11139 delete arg2;
11140 }
11141 return NULL;
11142 }
11143
11144
11145 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11146 PyObject *resultobj = 0;
11147 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11148 wxString result;
11149 void *argp1 = 0 ;
11150 int res1 = 0 ;
11151 PyObject *swig_obj[1] ;
11152
11153 if (!args) SWIG_fail;
11154 swig_obj[0] = args;
11155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11156 if (!SWIG_IsOK(res1)) {
11157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11158 }
11159 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11160 {
11161 PyThreadState* __tstate = wxPyBeginAllowThreads();
11162 result = (arg1)->FindNext();
11163 wxPyEndAllowThreads(__tstate);
11164 if (PyErr_Occurred()) SWIG_fail;
11165 }
11166 {
11167 #if wxUSE_UNICODE
11168 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11169 #else
11170 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11171 #endif
11172 }
11173 return resultobj;
11174 fail:
11175 return NULL;
11176 }
11177
11178
11179 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11180 PyObject *obj;
11181 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11182 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11183 return SWIG_Py_Void();
11184 }
11185
11186 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11187 return SWIG_Python_InitShadowInstance(args);
11188 }
11189
11190 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11191 PyObject *resultobj = 0;
11192 wxString *arg1 = 0 ;
11193 wxImage *arg2 = 0 ;
11194 long arg3 ;
11195 bool temp1 = false ;
11196 void *argp2 = 0 ;
11197 int res2 = 0 ;
11198 long val3 ;
11199 int ecode3 = 0 ;
11200 PyObject * obj0 = 0 ;
11201 PyObject * obj1 = 0 ;
11202 PyObject * obj2 = 0 ;
11203 char * kwnames[] = {
11204 (char *) "filename",(char *) "image",(char *) "type", NULL
11205 };
11206
11207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11208 {
11209 arg1 = wxString_in_helper(obj0);
11210 if (arg1 == NULL) SWIG_fail;
11211 temp1 = true;
11212 }
11213 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11214 if (!SWIG_IsOK(res2)) {
11215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11216 }
11217 if (!argp2) {
11218 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11219 }
11220 arg2 = reinterpret_cast< wxImage * >(argp2);
11221 ecode3 = SWIG_AsVal_long(obj2, &val3);
11222 if (!SWIG_IsOK(ecode3)) {
11223 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11224 }
11225 arg3 = static_cast< long >(val3);
11226 {
11227 PyThreadState* __tstate = wxPyBeginAllowThreads();
11228 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11229 wxPyEndAllowThreads(__tstate);
11230 if (PyErr_Occurred()) SWIG_fail;
11231 }
11232 resultobj = SWIG_Py_Void();
11233 {
11234 if (temp1)
11235 delete arg1;
11236 }
11237 return resultobj;
11238 fail:
11239 {
11240 if (temp1)
11241 delete arg1;
11242 }
11243 return NULL;
11244 }
11245
11246
11247 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11248 PyObject *resultobj = 0;
11249 wxString *arg1 = 0 ;
11250 wxBitmap *arg2 = 0 ;
11251 long arg3 ;
11252 bool temp1 = false ;
11253 void *argp2 = 0 ;
11254 int res2 = 0 ;
11255 long val3 ;
11256 int ecode3 = 0 ;
11257 PyObject * obj0 = 0 ;
11258 PyObject * obj1 = 0 ;
11259 PyObject * obj2 = 0 ;
11260 char * kwnames[] = {
11261 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11262 };
11263
11264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11265 {
11266 arg1 = wxString_in_helper(obj0);
11267 if (arg1 == NULL) SWIG_fail;
11268 temp1 = true;
11269 }
11270 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11271 if (!SWIG_IsOK(res2)) {
11272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11273 }
11274 if (!argp2) {
11275 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11276 }
11277 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11278 ecode3 = SWIG_AsVal_long(obj2, &val3);
11279 if (!SWIG_IsOK(ecode3)) {
11280 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11281 }
11282 arg3 = static_cast< long >(val3);
11283 {
11284 PyThreadState* __tstate = wxPyBeginAllowThreads();
11285 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11286 wxPyEndAllowThreads(__tstate);
11287 if (PyErr_Occurred()) SWIG_fail;
11288 }
11289 resultobj = SWIG_Py_Void();
11290 {
11291 if (temp1)
11292 delete arg1;
11293 }
11294 return resultobj;
11295 fail:
11296 {
11297 if (temp1)
11298 delete arg1;
11299 }
11300 return NULL;
11301 }
11302
11303
11304 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11305 PyObject *resultobj = 0;
11306 wxString *arg1 = 0 ;
11307 PyObject *arg2 = (PyObject *) 0 ;
11308 bool temp1 = false ;
11309 PyObject * obj0 = 0 ;
11310 PyObject * obj1 = 0 ;
11311 char * kwnames[] = {
11312 (char *) "filename",(char *) "data", NULL
11313 };
11314
11315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11316 {
11317 arg1 = wxString_in_helper(obj0);
11318 if (arg1 == NULL) SWIG_fail;
11319 temp1 = true;
11320 }
11321 arg2 = obj1;
11322 {
11323 PyThreadState* __tstate = wxPyBeginAllowThreads();
11324 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11325 wxPyEndAllowThreads(__tstate);
11326 if (PyErr_Occurred()) SWIG_fail;
11327 }
11328 resultobj = SWIG_Py_Void();
11329 {
11330 if (temp1)
11331 delete arg1;
11332 }
11333 return resultobj;
11334 fail:
11335 {
11336 if (temp1)
11337 delete arg1;
11338 }
11339 return NULL;
11340 }
11341
11342
11343 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11344 PyObject *resultobj = 0;
11345 wxMemoryFSHandler *result = 0 ;
11346
11347 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11348 {
11349 PyThreadState* __tstate = wxPyBeginAllowThreads();
11350 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11351 wxPyEndAllowThreads(__tstate);
11352 if (PyErr_Occurred()) SWIG_fail;
11353 }
11354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11355 return resultobj;
11356 fail:
11357 return NULL;
11358 }
11359
11360
11361 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11362 PyObject *resultobj = 0;
11363 wxString *arg1 = 0 ;
11364 bool temp1 = false ;
11365 PyObject * obj0 = 0 ;
11366 char * kwnames[] = {
11367 (char *) "filename", NULL
11368 };
11369
11370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11371 {
11372 arg1 = wxString_in_helper(obj0);
11373 if (arg1 == NULL) SWIG_fail;
11374 temp1 = true;
11375 }
11376 {
11377 PyThreadState* __tstate = wxPyBeginAllowThreads();
11378 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11379 wxPyEndAllowThreads(__tstate);
11380 if (PyErr_Occurred()) SWIG_fail;
11381 }
11382 resultobj = SWIG_Py_Void();
11383 {
11384 if (temp1)
11385 delete arg1;
11386 }
11387 return resultobj;
11388 fail:
11389 {
11390 if (temp1)
11391 delete arg1;
11392 }
11393 return NULL;
11394 }
11395
11396
11397 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11398 PyObject *resultobj = 0;
11399 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11400 wxString *arg2 = 0 ;
11401 bool result;
11402 void *argp1 = 0 ;
11403 int res1 = 0 ;
11404 bool temp2 = false ;
11405 PyObject * obj0 = 0 ;
11406 PyObject * obj1 = 0 ;
11407 char * kwnames[] = {
11408 (char *) "self",(char *) "location", NULL
11409 };
11410
11411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11413 if (!SWIG_IsOK(res1)) {
11414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11415 }
11416 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11417 {
11418 arg2 = wxString_in_helper(obj1);
11419 if (arg2 == NULL) SWIG_fail;
11420 temp2 = true;
11421 }
11422 {
11423 PyThreadState* __tstate = wxPyBeginAllowThreads();
11424 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11425 wxPyEndAllowThreads(__tstate);
11426 if (PyErr_Occurred()) SWIG_fail;
11427 }
11428 {
11429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11430 }
11431 {
11432 if (temp2)
11433 delete arg2;
11434 }
11435 return resultobj;
11436 fail:
11437 {
11438 if (temp2)
11439 delete arg2;
11440 }
11441 return NULL;
11442 }
11443
11444
11445 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11446 PyObject *resultobj = 0;
11447 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11448 wxFileSystem *arg2 = 0 ;
11449 wxString *arg3 = 0 ;
11450 wxFSFile *result = 0 ;
11451 void *argp1 = 0 ;
11452 int res1 = 0 ;
11453 void *argp2 = 0 ;
11454 int res2 = 0 ;
11455 bool temp3 = false ;
11456 PyObject * obj0 = 0 ;
11457 PyObject * obj1 = 0 ;
11458 PyObject * obj2 = 0 ;
11459 char * kwnames[] = {
11460 (char *) "self",(char *) "fs",(char *) "location", NULL
11461 };
11462
11463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) 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_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11467 }
11468 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11469 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11470 if (!SWIG_IsOK(res2)) {
11471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11472 }
11473 if (!argp2) {
11474 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11475 }
11476 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11477 {
11478 arg3 = wxString_in_helper(obj2);
11479 if (arg3 == NULL) SWIG_fail;
11480 temp3 = true;
11481 }
11482 {
11483 PyThreadState* __tstate = wxPyBeginAllowThreads();
11484 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11485 wxPyEndAllowThreads(__tstate);
11486 if (PyErr_Occurred()) SWIG_fail;
11487 }
11488 {
11489 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11490 }
11491 {
11492 if (temp3)
11493 delete arg3;
11494 }
11495 return resultobj;
11496 fail:
11497 {
11498 if (temp3)
11499 delete arg3;
11500 }
11501 return NULL;
11502 }
11503
11504
11505 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11506 PyObject *resultobj = 0;
11507 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11508 wxString *arg2 = 0 ;
11509 int arg3 = (int) 0 ;
11510 wxString result;
11511 void *argp1 = 0 ;
11512 int res1 = 0 ;
11513 bool temp2 = false ;
11514 int val3 ;
11515 int ecode3 = 0 ;
11516 PyObject * obj0 = 0 ;
11517 PyObject * obj1 = 0 ;
11518 PyObject * obj2 = 0 ;
11519 char * kwnames[] = {
11520 (char *) "self",(char *) "spec",(char *) "flags", NULL
11521 };
11522
11523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11525 if (!SWIG_IsOK(res1)) {
11526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11527 }
11528 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11529 {
11530 arg2 = wxString_in_helper(obj1);
11531 if (arg2 == NULL) SWIG_fail;
11532 temp2 = true;
11533 }
11534 if (obj2) {
11535 ecode3 = SWIG_AsVal_int(obj2, &val3);
11536 if (!SWIG_IsOK(ecode3)) {
11537 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11538 }
11539 arg3 = static_cast< int >(val3);
11540 }
11541 {
11542 PyThreadState* __tstate = wxPyBeginAllowThreads();
11543 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11544 wxPyEndAllowThreads(__tstate);
11545 if (PyErr_Occurred()) SWIG_fail;
11546 }
11547 {
11548 #if wxUSE_UNICODE
11549 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11550 #else
11551 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11552 #endif
11553 }
11554 {
11555 if (temp2)
11556 delete arg2;
11557 }
11558 return resultobj;
11559 fail:
11560 {
11561 if (temp2)
11562 delete arg2;
11563 }
11564 return NULL;
11565 }
11566
11567
11568 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11569 PyObject *resultobj = 0;
11570 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11571 wxString result;
11572 void *argp1 = 0 ;
11573 int res1 = 0 ;
11574 PyObject *swig_obj[1] ;
11575
11576 if (!args) SWIG_fail;
11577 swig_obj[0] = args;
11578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11579 if (!SWIG_IsOK(res1)) {
11580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11581 }
11582 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11583 {
11584 PyThreadState* __tstate = wxPyBeginAllowThreads();
11585 result = (arg1)->FindNext();
11586 wxPyEndAllowThreads(__tstate);
11587 if (PyErr_Occurred()) SWIG_fail;
11588 }
11589 {
11590 #if wxUSE_UNICODE
11591 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11592 #else
11593 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11594 #endif
11595 }
11596 return resultobj;
11597 fail:
11598 return NULL;
11599 }
11600
11601
11602 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11603 PyObject *obj;
11604 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11605 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11606 return SWIG_Py_Void();
11607 }
11608
11609 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11610 return SWIG_Python_InitShadowInstance(args);
11611 }
11612
11613 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11614 PyObject *resultobj = 0;
11615 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11616 wxString result;
11617 void *argp1 = 0 ;
11618 int res1 = 0 ;
11619 PyObject *swig_obj[1] ;
11620
11621 if (!args) SWIG_fail;
11622 swig_obj[0] = args;
11623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11624 if (!SWIG_IsOK(res1)) {
11625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11626 }
11627 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11628 {
11629 PyThreadState* __tstate = wxPyBeginAllowThreads();
11630 result = (arg1)->GetName();
11631 wxPyEndAllowThreads(__tstate);
11632 if (PyErr_Occurred()) SWIG_fail;
11633 }
11634 {
11635 #if wxUSE_UNICODE
11636 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11637 #else
11638 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11639 #endif
11640 }
11641 return resultobj;
11642 fail:
11643 return NULL;
11644 }
11645
11646
11647 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11648 PyObject *resultobj = 0;
11649 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11650 wxString result;
11651 void *argp1 = 0 ;
11652 int res1 = 0 ;
11653 PyObject *swig_obj[1] ;
11654
11655 if (!args) SWIG_fail;
11656 swig_obj[0] = args;
11657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11658 if (!SWIG_IsOK(res1)) {
11659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11660 }
11661 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11662 {
11663 PyThreadState* __tstate = wxPyBeginAllowThreads();
11664 result = (arg1)->GetExtension();
11665 wxPyEndAllowThreads(__tstate);
11666 if (PyErr_Occurred()) SWIG_fail;
11667 }
11668 {
11669 #if wxUSE_UNICODE
11670 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11671 #else
11672 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11673 #endif
11674 }
11675 return resultobj;
11676 fail:
11677 return NULL;
11678 }
11679
11680
11681 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11682 PyObject *resultobj = 0;
11683 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11684 long result;
11685 void *argp1 = 0 ;
11686 int res1 = 0 ;
11687 PyObject *swig_obj[1] ;
11688
11689 if (!args) SWIG_fail;
11690 swig_obj[0] = args;
11691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11692 if (!SWIG_IsOK(res1)) {
11693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11694 }
11695 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11696 {
11697 PyThreadState* __tstate = wxPyBeginAllowThreads();
11698 result = (long)(arg1)->GetType();
11699 wxPyEndAllowThreads(__tstate);
11700 if (PyErr_Occurred()) SWIG_fail;
11701 }
11702 resultobj = SWIG_From_long(static_cast< long >(result));
11703 return resultobj;
11704 fail:
11705 return NULL;
11706 }
11707
11708
11709 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11710 PyObject *resultobj = 0;
11711 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11712 wxString result;
11713 void *argp1 = 0 ;
11714 int res1 = 0 ;
11715 PyObject *swig_obj[1] ;
11716
11717 if (!args) SWIG_fail;
11718 swig_obj[0] = args;
11719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11720 if (!SWIG_IsOK(res1)) {
11721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11722 }
11723 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11724 {
11725 PyThreadState* __tstate = wxPyBeginAllowThreads();
11726 result = (arg1)->GetMimeType();
11727 wxPyEndAllowThreads(__tstate);
11728 if (PyErr_Occurred()) SWIG_fail;
11729 }
11730 {
11731 #if wxUSE_UNICODE
11732 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11733 #else
11734 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11735 #endif
11736 }
11737 return resultobj;
11738 fail:
11739 return NULL;
11740 }
11741
11742
11743 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11744 PyObject *resultobj = 0;
11745 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11746 wxString *arg2 = 0 ;
11747 bool result;
11748 void *argp1 = 0 ;
11749 int res1 = 0 ;
11750 bool temp2 = false ;
11751 PyObject * obj0 = 0 ;
11752 PyObject * obj1 = 0 ;
11753 char * kwnames[] = {
11754 (char *) "self",(char *) "name", NULL
11755 };
11756
11757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11759 if (!SWIG_IsOK(res1)) {
11760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11761 }
11762 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11763 {
11764 arg2 = wxString_in_helper(obj1);
11765 if (arg2 == NULL) SWIG_fail;
11766 temp2 = true;
11767 }
11768 {
11769 PyThreadState* __tstate = wxPyBeginAllowThreads();
11770 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11771 wxPyEndAllowThreads(__tstate);
11772 if (PyErr_Occurred()) SWIG_fail;
11773 }
11774 {
11775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11776 }
11777 {
11778 if (temp2)
11779 delete arg2;
11780 }
11781 return resultobj;
11782 fail:
11783 {
11784 if (temp2)
11785 delete arg2;
11786 }
11787 return NULL;
11788 }
11789
11790
11791 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11792 PyObject *resultobj = 0;
11793 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11794 wxString *arg2 = 0 ;
11795 void *argp1 = 0 ;
11796 int res1 = 0 ;
11797 bool temp2 = false ;
11798 PyObject * obj0 = 0 ;
11799 PyObject * obj1 = 0 ;
11800 char * kwnames[] = {
11801 (char *) "self",(char *) "name", NULL
11802 };
11803
11804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11806 if (!SWIG_IsOK(res1)) {
11807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11808 }
11809 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11810 {
11811 arg2 = wxString_in_helper(obj1);
11812 if (arg2 == NULL) SWIG_fail;
11813 temp2 = true;
11814 }
11815 {
11816 PyThreadState* __tstate = wxPyBeginAllowThreads();
11817 (arg1)->SetName((wxString const &)*arg2);
11818 wxPyEndAllowThreads(__tstate);
11819 if (PyErr_Occurred()) SWIG_fail;
11820 }
11821 resultobj = SWIG_Py_Void();
11822 {
11823 if (temp2)
11824 delete arg2;
11825 }
11826 return resultobj;
11827 fail:
11828 {
11829 if (temp2)
11830 delete arg2;
11831 }
11832 return NULL;
11833 }
11834
11835
11836 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11837 PyObject *resultobj = 0;
11838 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11839 wxString *arg2 = 0 ;
11840 void *argp1 = 0 ;
11841 int res1 = 0 ;
11842 bool temp2 = false ;
11843 PyObject * obj0 = 0 ;
11844 PyObject * obj1 = 0 ;
11845 char * kwnames[] = {
11846 (char *) "self",(char *) "extension", NULL
11847 };
11848
11849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11851 if (!SWIG_IsOK(res1)) {
11852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11853 }
11854 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11855 {
11856 arg2 = wxString_in_helper(obj1);
11857 if (arg2 == NULL) SWIG_fail;
11858 temp2 = true;
11859 }
11860 {
11861 PyThreadState* __tstate = wxPyBeginAllowThreads();
11862 (arg1)->SetExtension((wxString const &)*arg2);
11863 wxPyEndAllowThreads(__tstate);
11864 if (PyErr_Occurred()) SWIG_fail;
11865 }
11866 resultobj = SWIG_Py_Void();
11867 {
11868 if (temp2)
11869 delete arg2;
11870 }
11871 return resultobj;
11872 fail:
11873 {
11874 if (temp2)
11875 delete arg2;
11876 }
11877 return NULL;
11878 }
11879
11880
11881 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11882 PyObject *resultobj = 0;
11883 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11884 long arg2 ;
11885 void *argp1 = 0 ;
11886 int res1 = 0 ;
11887 long val2 ;
11888 int ecode2 = 0 ;
11889 PyObject * obj0 = 0 ;
11890 PyObject * obj1 = 0 ;
11891 char * kwnames[] = {
11892 (char *) "self",(char *) "type", NULL
11893 };
11894
11895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11897 if (!SWIG_IsOK(res1)) {
11898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11899 }
11900 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11901 ecode2 = SWIG_AsVal_long(obj1, &val2);
11902 if (!SWIG_IsOK(ecode2)) {
11903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11904 }
11905 arg2 = static_cast< long >(val2);
11906 {
11907 PyThreadState* __tstate = wxPyBeginAllowThreads();
11908 (arg1)->SetType(arg2);
11909 wxPyEndAllowThreads(__tstate);
11910 if (PyErr_Occurred()) SWIG_fail;
11911 }
11912 resultobj = SWIG_Py_Void();
11913 return resultobj;
11914 fail:
11915 return NULL;
11916 }
11917
11918
11919 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11920 PyObject *resultobj = 0;
11921 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11922 wxString *arg2 = 0 ;
11923 void *argp1 = 0 ;
11924 int res1 = 0 ;
11925 bool temp2 = false ;
11926 PyObject * obj0 = 0 ;
11927 PyObject * obj1 = 0 ;
11928 char * kwnames[] = {
11929 (char *) "self",(char *) "mimetype", NULL
11930 };
11931
11932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11934 if (!SWIG_IsOK(res1)) {
11935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11936 }
11937 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11938 {
11939 arg2 = wxString_in_helper(obj1);
11940 if (arg2 == NULL) SWIG_fail;
11941 temp2 = true;
11942 }
11943 {
11944 PyThreadState* __tstate = wxPyBeginAllowThreads();
11945 (arg1)->SetMimeType((wxString const &)*arg2);
11946 wxPyEndAllowThreads(__tstate);
11947 if (PyErr_Occurred()) SWIG_fail;
11948 }
11949 resultobj = SWIG_Py_Void();
11950 {
11951 if (temp2)
11952 delete arg2;
11953 }
11954 return resultobj;
11955 fail:
11956 {
11957 if (temp2)
11958 delete arg2;
11959 }
11960 return NULL;
11961 }
11962
11963
11964 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11965 PyObject *obj;
11966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11967 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
11968 return SWIG_Py_Void();
11969 }
11970
11971 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11972 PyObject *resultobj = 0;
11973 wxPyImageHandler *result = 0 ;
11974
11975 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
11976 {
11977 PyThreadState* __tstate = wxPyBeginAllowThreads();
11978 result = (wxPyImageHandler *)new wxPyImageHandler();
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
11983 return resultobj;
11984 fail:
11985 return NULL;
11986 }
11987
11988
11989 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11990 PyObject *resultobj = 0;
11991 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
11992 PyObject *arg2 = (PyObject *) 0 ;
11993 void *argp1 = 0 ;
11994 int res1 = 0 ;
11995 PyObject * obj0 = 0 ;
11996 PyObject * obj1 = 0 ;
11997 char * kwnames[] = {
11998 (char *) "self",(char *) "self", NULL
11999 };
12000
12001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12003 if (!SWIG_IsOK(res1)) {
12004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12005 }
12006 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12007 arg2 = obj1;
12008 {
12009 PyThreadState* __tstate = wxPyBeginAllowThreads();
12010 (arg1)->_SetSelf(arg2);
12011 wxPyEndAllowThreads(__tstate);
12012 if (PyErr_Occurred()) SWIG_fail;
12013 }
12014 resultobj = SWIG_Py_Void();
12015 return resultobj;
12016 fail:
12017 return NULL;
12018 }
12019
12020
12021 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12022 PyObject *obj;
12023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12024 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12025 return SWIG_Py_Void();
12026 }
12027
12028 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12029 return SWIG_Python_InitShadowInstance(args);
12030 }
12031
12032 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12033 PyObject *resultobj = 0;
12034 wxImageHistogram *result = 0 ;
12035
12036 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12037 {
12038 PyThreadState* __tstate = wxPyBeginAllowThreads();
12039 result = (wxImageHistogram *)new wxImageHistogram();
12040 wxPyEndAllowThreads(__tstate);
12041 if (PyErr_Occurred()) SWIG_fail;
12042 }
12043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12044 return resultobj;
12045 fail:
12046 return NULL;
12047 }
12048
12049
12050 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12051 PyObject *resultobj = 0;
12052 byte arg1 ;
12053 byte arg2 ;
12054 byte arg3 ;
12055 unsigned long result;
12056 unsigned char val1 ;
12057 int ecode1 = 0 ;
12058 unsigned char val2 ;
12059 int ecode2 = 0 ;
12060 unsigned char val3 ;
12061 int ecode3 = 0 ;
12062 PyObject * obj0 = 0 ;
12063 PyObject * obj1 = 0 ;
12064 PyObject * obj2 = 0 ;
12065 char * kwnames[] = {
12066 (char *) "r",(char *) "g",(char *) "b", NULL
12067 };
12068
12069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12070 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12071 if (!SWIG_IsOK(ecode1)) {
12072 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12073 }
12074 arg1 = static_cast< byte >(val1);
12075 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12076 if (!SWIG_IsOK(ecode2)) {
12077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12078 }
12079 arg2 = static_cast< byte >(val2);
12080 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12081 if (!SWIG_IsOK(ecode3)) {
12082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12083 }
12084 arg3 = static_cast< byte >(val3);
12085 {
12086 PyThreadState* __tstate = wxPyBeginAllowThreads();
12087 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12088 wxPyEndAllowThreads(__tstate);
12089 if (PyErr_Occurred()) SWIG_fail;
12090 }
12091 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12092 return resultobj;
12093 fail:
12094 return NULL;
12095 }
12096
12097
12098 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12099 PyObject *resultobj = 0;
12100 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12101 byte *arg2 = (byte *) 0 ;
12102 byte *arg3 = (byte *) 0 ;
12103 byte *arg4 = (byte *) 0 ;
12104 byte arg5 = (byte) 1 ;
12105 byte arg6 = (byte) 0 ;
12106 byte arg7 = (byte) 0 ;
12107 bool result;
12108 void *argp1 = 0 ;
12109 int res1 = 0 ;
12110 byte temp2 ;
12111 int res2 = SWIG_TMPOBJ ;
12112 byte temp3 ;
12113 int res3 = SWIG_TMPOBJ ;
12114 byte temp4 ;
12115 int res4 = SWIG_TMPOBJ ;
12116 unsigned char val5 ;
12117 int ecode5 = 0 ;
12118 unsigned char val6 ;
12119 int ecode6 = 0 ;
12120 unsigned char val7 ;
12121 int ecode7 = 0 ;
12122 PyObject * obj0 = 0 ;
12123 PyObject * obj1 = 0 ;
12124 PyObject * obj2 = 0 ;
12125 PyObject * obj3 = 0 ;
12126 char * kwnames[] = {
12127 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12128 };
12129
12130 arg2 = &temp2;
12131 arg3 = &temp3;
12132 arg4 = &temp4;
12133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12135 if (!SWIG_IsOK(res1)) {
12136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12137 }
12138 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12139 if (obj1) {
12140 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12141 if (!SWIG_IsOK(ecode5)) {
12142 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12143 }
12144 arg5 = static_cast< byte >(val5);
12145 }
12146 if (obj2) {
12147 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12148 if (!SWIG_IsOK(ecode6)) {
12149 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12150 }
12151 arg6 = static_cast< byte >(val6);
12152 }
12153 if (obj3) {
12154 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12155 if (!SWIG_IsOK(ecode7)) {
12156 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12157 }
12158 arg7 = static_cast< byte >(val7);
12159 }
12160 {
12161 PyThreadState* __tstate = wxPyBeginAllowThreads();
12162 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12163 wxPyEndAllowThreads(__tstate);
12164 if (PyErr_Occurred()) SWIG_fail;
12165 }
12166 {
12167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12168 }
12169 if (SWIG_IsTmpObj(res2)) {
12170 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12171 } else {
12172 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12174 }
12175 if (SWIG_IsTmpObj(res3)) {
12176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12177 } else {
12178 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12180 }
12181 if (SWIG_IsTmpObj(res4)) {
12182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12183 } else {
12184 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12185 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12186 }
12187 return resultobj;
12188 fail:
12189 return NULL;
12190 }
12191
12192
12193 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12194 PyObject *resultobj = 0;
12195 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12196 unsigned long arg2 ;
12197 unsigned long result;
12198 void *argp1 = 0 ;
12199 int res1 = 0 ;
12200 unsigned long val2 ;
12201 int ecode2 = 0 ;
12202 PyObject * obj0 = 0 ;
12203 PyObject * obj1 = 0 ;
12204 char * kwnames[] = {
12205 (char *) "self",(char *) "key", NULL
12206 };
12207
12208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12210 if (!SWIG_IsOK(res1)) {
12211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12212 }
12213 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12214 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12215 if (!SWIG_IsOK(ecode2)) {
12216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12217 }
12218 arg2 = static_cast< unsigned long >(val2);
12219 {
12220 PyThreadState* __tstate = wxPyBeginAllowThreads();
12221 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12222 wxPyEndAllowThreads(__tstate);
12223 if (PyErr_Occurred()) SWIG_fail;
12224 }
12225 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12226 return resultobj;
12227 fail:
12228 return NULL;
12229 }
12230
12231
12232 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12233 PyObject *resultobj = 0;
12234 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12235 byte arg2 ;
12236 byte arg3 ;
12237 byte arg4 ;
12238 unsigned long result;
12239 void *argp1 = 0 ;
12240 int res1 = 0 ;
12241 unsigned char val2 ;
12242 int ecode2 = 0 ;
12243 unsigned char val3 ;
12244 int ecode3 = 0 ;
12245 unsigned char val4 ;
12246 int ecode4 = 0 ;
12247 PyObject * obj0 = 0 ;
12248 PyObject * obj1 = 0 ;
12249 PyObject * obj2 = 0 ;
12250 PyObject * obj3 = 0 ;
12251 char * kwnames[] = {
12252 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12253 };
12254
12255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12257 if (!SWIG_IsOK(res1)) {
12258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12259 }
12260 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12261 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12262 if (!SWIG_IsOK(ecode2)) {
12263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12264 }
12265 arg2 = static_cast< byte >(val2);
12266 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12267 if (!SWIG_IsOK(ecode3)) {
12268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12269 }
12270 arg3 = static_cast< byte >(val3);
12271 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12272 if (!SWIG_IsOK(ecode4)) {
12273 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12274 }
12275 arg4 = static_cast< byte >(val4);
12276 {
12277 PyThreadState* __tstate = wxPyBeginAllowThreads();
12278 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12279 wxPyEndAllowThreads(__tstate);
12280 if (PyErr_Occurred()) SWIG_fail;
12281 }
12282 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12283 return resultobj;
12284 fail:
12285 return NULL;
12286 }
12287
12288
12289 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12290 PyObject *resultobj = 0;
12291 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12292 wxColour *arg2 = 0 ;
12293 unsigned long result;
12294 void *argp1 = 0 ;
12295 int res1 = 0 ;
12296 wxColour temp2 ;
12297 PyObject * obj0 = 0 ;
12298 PyObject * obj1 = 0 ;
12299 char * kwnames[] = {
12300 (char *) "self",(char *) "colour", NULL
12301 };
12302
12303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12305 if (!SWIG_IsOK(res1)) {
12306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12307 }
12308 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12309 {
12310 arg2 = &temp2;
12311 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12312 }
12313 {
12314 PyThreadState* __tstate = wxPyBeginAllowThreads();
12315 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12316 wxPyEndAllowThreads(__tstate);
12317 if (PyErr_Occurred()) SWIG_fail;
12318 }
12319 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12320 return resultobj;
12321 fail:
12322 return NULL;
12323 }
12324
12325
12326 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12327 PyObject *obj;
12328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12329 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12330 return SWIG_Py_Void();
12331 }
12332
12333 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12334 return SWIG_Python_InitShadowInstance(args);
12335 }
12336
12337 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12338 PyObject *resultobj = 0;
12339 byte arg1 = (byte) 0 ;
12340 byte arg2 = (byte) 0 ;
12341 byte arg3 = (byte) 0 ;
12342 wxImage_RGBValue *result = 0 ;
12343 unsigned char val1 ;
12344 int ecode1 = 0 ;
12345 unsigned char val2 ;
12346 int ecode2 = 0 ;
12347 unsigned char val3 ;
12348 int ecode3 = 0 ;
12349 PyObject * obj0 = 0 ;
12350 PyObject * obj1 = 0 ;
12351 PyObject * obj2 = 0 ;
12352 char * kwnames[] = {
12353 (char *) "r",(char *) "g",(char *) "b", NULL
12354 };
12355
12356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12357 if (obj0) {
12358 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12359 if (!SWIG_IsOK(ecode1)) {
12360 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12361 }
12362 arg1 = static_cast< byte >(val1);
12363 }
12364 if (obj1) {
12365 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12366 if (!SWIG_IsOK(ecode2)) {
12367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12368 }
12369 arg2 = static_cast< byte >(val2);
12370 }
12371 if (obj2) {
12372 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12373 if (!SWIG_IsOK(ecode3)) {
12374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12375 }
12376 arg3 = static_cast< byte >(val3);
12377 }
12378 {
12379 PyThreadState* __tstate = wxPyBeginAllowThreads();
12380 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12381 wxPyEndAllowThreads(__tstate);
12382 if (PyErr_Occurred()) SWIG_fail;
12383 }
12384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12385 return resultobj;
12386 fail:
12387 return NULL;
12388 }
12389
12390
12391 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12392 PyObject *resultobj = 0;
12393 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12394 byte arg2 ;
12395 void *argp1 = 0 ;
12396 int res1 = 0 ;
12397 unsigned char val2 ;
12398 int ecode2 = 0 ;
12399 PyObject *swig_obj[2] ;
12400
12401 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12403 if (!SWIG_IsOK(res1)) {
12404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12405 }
12406 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12407 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12408 if (!SWIG_IsOK(ecode2)) {
12409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12410 }
12411 arg2 = static_cast< byte >(val2);
12412 if (arg1) (arg1)->red = arg2;
12413
12414 resultobj = SWIG_Py_Void();
12415 return resultobj;
12416 fail:
12417 return NULL;
12418 }
12419
12420
12421 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12422 PyObject *resultobj = 0;
12423 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12424 byte result;
12425 void *argp1 = 0 ;
12426 int res1 = 0 ;
12427 PyObject *swig_obj[1] ;
12428
12429 if (!args) SWIG_fail;
12430 swig_obj[0] = args;
12431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12432 if (!SWIG_IsOK(res1)) {
12433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12434 }
12435 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12436 result = (byte) ((arg1)->red);
12437 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12438 return resultobj;
12439 fail:
12440 return NULL;
12441 }
12442
12443
12444 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12445 PyObject *resultobj = 0;
12446 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12447 byte arg2 ;
12448 void *argp1 = 0 ;
12449 int res1 = 0 ;
12450 unsigned char val2 ;
12451 int ecode2 = 0 ;
12452 PyObject *swig_obj[2] ;
12453
12454 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12456 if (!SWIG_IsOK(res1)) {
12457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12458 }
12459 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12460 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12461 if (!SWIG_IsOK(ecode2)) {
12462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12463 }
12464 arg2 = static_cast< byte >(val2);
12465 if (arg1) (arg1)->green = arg2;
12466
12467 resultobj = SWIG_Py_Void();
12468 return resultobj;
12469 fail:
12470 return NULL;
12471 }
12472
12473
12474 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12475 PyObject *resultobj = 0;
12476 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12477 byte result;
12478 void *argp1 = 0 ;
12479 int res1 = 0 ;
12480 PyObject *swig_obj[1] ;
12481
12482 if (!args) SWIG_fail;
12483 swig_obj[0] = args;
12484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12485 if (!SWIG_IsOK(res1)) {
12486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12487 }
12488 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12489 result = (byte) ((arg1)->green);
12490 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12491 return resultobj;
12492 fail:
12493 return NULL;
12494 }
12495
12496
12497 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12498 PyObject *resultobj = 0;
12499 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12500 byte arg2 ;
12501 void *argp1 = 0 ;
12502 int res1 = 0 ;
12503 unsigned char val2 ;
12504 int ecode2 = 0 ;
12505 PyObject *swig_obj[2] ;
12506
12507 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12509 if (!SWIG_IsOK(res1)) {
12510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12511 }
12512 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12513 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12514 if (!SWIG_IsOK(ecode2)) {
12515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12516 }
12517 arg2 = static_cast< byte >(val2);
12518 if (arg1) (arg1)->blue = arg2;
12519
12520 resultobj = SWIG_Py_Void();
12521 return resultobj;
12522 fail:
12523 return NULL;
12524 }
12525
12526
12527 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12528 PyObject *resultobj = 0;
12529 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12530 byte result;
12531 void *argp1 = 0 ;
12532 int res1 = 0 ;
12533 PyObject *swig_obj[1] ;
12534
12535 if (!args) SWIG_fail;
12536 swig_obj[0] = args;
12537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12538 if (!SWIG_IsOK(res1)) {
12539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12540 }
12541 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12542 result = (byte) ((arg1)->blue);
12543 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12544 return resultobj;
12545 fail:
12546 return NULL;
12547 }
12548
12549
12550 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12551 PyObject *obj;
12552 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12553 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12554 return SWIG_Py_Void();
12555 }
12556
12557 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12558 return SWIG_Python_InitShadowInstance(args);
12559 }
12560
12561 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12562 PyObject *resultobj = 0;
12563 double arg1 = (double) 0.0 ;
12564 double arg2 = (double) 0.0 ;
12565 double arg3 = (double) 0.0 ;
12566 wxImage_HSVValue *result = 0 ;
12567 double val1 ;
12568 int ecode1 = 0 ;
12569 double val2 ;
12570 int ecode2 = 0 ;
12571 double val3 ;
12572 int ecode3 = 0 ;
12573 PyObject * obj0 = 0 ;
12574 PyObject * obj1 = 0 ;
12575 PyObject * obj2 = 0 ;
12576 char * kwnames[] = {
12577 (char *) "h",(char *) "s",(char *) "v", NULL
12578 };
12579
12580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12581 if (obj0) {
12582 ecode1 = SWIG_AsVal_double(obj0, &val1);
12583 if (!SWIG_IsOK(ecode1)) {
12584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12585 }
12586 arg1 = static_cast< double >(val1);
12587 }
12588 if (obj1) {
12589 ecode2 = SWIG_AsVal_double(obj1, &val2);
12590 if (!SWIG_IsOK(ecode2)) {
12591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12592 }
12593 arg2 = static_cast< double >(val2);
12594 }
12595 if (obj2) {
12596 ecode3 = SWIG_AsVal_double(obj2, &val3);
12597 if (!SWIG_IsOK(ecode3)) {
12598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12599 }
12600 arg3 = static_cast< double >(val3);
12601 }
12602 {
12603 PyThreadState* __tstate = wxPyBeginAllowThreads();
12604 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12605 wxPyEndAllowThreads(__tstate);
12606 if (PyErr_Occurred()) SWIG_fail;
12607 }
12608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12609 return resultobj;
12610 fail:
12611 return NULL;
12612 }
12613
12614
12615 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12616 PyObject *resultobj = 0;
12617 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12618 double arg2 ;
12619 void *argp1 = 0 ;
12620 int res1 = 0 ;
12621 double val2 ;
12622 int ecode2 = 0 ;
12623 PyObject *swig_obj[2] ;
12624
12625 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12627 if (!SWIG_IsOK(res1)) {
12628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12629 }
12630 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12631 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12632 if (!SWIG_IsOK(ecode2)) {
12633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12634 }
12635 arg2 = static_cast< double >(val2);
12636 if (arg1) (arg1)->hue = arg2;
12637
12638 resultobj = SWIG_Py_Void();
12639 return resultobj;
12640 fail:
12641 return NULL;
12642 }
12643
12644
12645 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12646 PyObject *resultobj = 0;
12647 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12648 double result;
12649 void *argp1 = 0 ;
12650 int res1 = 0 ;
12651 PyObject *swig_obj[1] ;
12652
12653 if (!args) SWIG_fail;
12654 swig_obj[0] = args;
12655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12656 if (!SWIG_IsOK(res1)) {
12657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12658 }
12659 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12660 result = (double) ((arg1)->hue);
12661 resultobj = SWIG_From_double(static_cast< double >(result));
12662 return resultobj;
12663 fail:
12664 return NULL;
12665 }
12666
12667
12668 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12669 PyObject *resultobj = 0;
12670 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12671 double arg2 ;
12672 void *argp1 = 0 ;
12673 int res1 = 0 ;
12674 double val2 ;
12675 int ecode2 = 0 ;
12676 PyObject *swig_obj[2] ;
12677
12678 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12680 if (!SWIG_IsOK(res1)) {
12681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12682 }
12683 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12684 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12685 if (!SWIG_IsOK(ecode2)) {
12686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12687 }
12688 arg2 = static_cast< double >(val2);
12689 if (arg1) (arg1)->saturation = arg2;
12690
12691 resultobj = SWIG_Py_Void();
12692 return resultobj;
12693 fail:
12694 return NULL;
12695 }
12696
12697
12698 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12699 PyObject *resultobj = 0;
12700 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12701 double result;
12702 void *argp1 = 0 ;
12703 int res1 = 0 ;
12704 PyObject *swig_obj[1] ;
12705
12706 if (!args) SWIG_fail;
12707 swig_obj[0] = args;
12708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12709 if (!SWIG_IsOK(res1)) {
12710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12711 }
12712 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12713 result = (double) ((arg1)->saturation);
12714 resultobj = SWIG_From_double(static_cast< double >(result));
12715 return resultobj;
12716 fail:
12717 return NULL;
12718 }
12719
12720
12721 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12722 PyObject *resultobj = 0;
12723 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12724 double arg2 ;
12725 void *argp1 = 0 ;
12726 int res1 = 0 ;
12727 double val2 ;
12728 int ecode2 = 0 ;
12729 PyObject *swig_obj[2] ;
12730
12731 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12733 if (!SWIG_IsOK(res1)) {
12734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12735 }
12736 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12737 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12738 if (!SWIG_IsOK(ecode2)) {
12739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12740 }
12741 arg2 = static_cast< double >(val2);
12742 if (arg1) (arg1)->value = arg2;
12743
12744 resultobj = SWIG_Py_Void();
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12752 PyObject *resultobj = 0;
12753 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12754 double result;
12755 void *argp1 = 0 ;
12756 int res1 = 0 ;
12757 PyObject *swig_obj[1] ;
12758
12759 if (!args) SWIG_fail;
12760 swig_obj[0] = args;
12761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12762 if (!SWIG_IsOK(res1)) {
12763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12764 }
12765 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12766 result = (double) ((arg1)->value);
12767 resultobj = SWIG_From_double(static_cast< double >(result));
12768 return resultobj;
12769 fail:
12770 return NULL;
12771 }
12772
12773
12774 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12775 PyObject *obj;
12776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12777 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12778 return SWIG_Py_Void();
12779 }
12780
12781 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12782 return SWIG_Python_InitShadowInstance(args);
12783 }
12784
12785 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12786 PyObject *resultobj = 0;
12787 wxString *arg1 = 0 ;
12788 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12789 int arg3 = (int) -1 ;
12790 wxImage *result = 0 ;
12791 bool temp1 = false ;
12792 long val2 ;
12793 int ecode2 = 0 ;
12794 int val3 ;
12795 int ecode3 = 0 ;
12796 PyObject * obj0 = 0 ;
12797 PyObject * obj1 = 0 ;
12798 PyObject * obj2 = 0 ;
12799 char * kwnames[] = {
12800 (char *) "name",(char *) "type",(char *) "index", NULL
12801 };
12802
12803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12804 {
12805 arg1 = wxString_in_helper(obj0);
12806 if (arg1 == NULL) SWIG_fail;
12807 temp1 = true;
12808 }
12809 if (obj1) {
12810 ecode2 = SWIG_AsVal_long(obj1, &val2);
12811 if (!SWIG_IsOK(ecode2)) {
12812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12813 }
12814 arg2 = static_cast< long >(val2);
12815 }
12816 if (obj2) {
12817 ecode3 = SWIG_AsVal_int(obj2, &val3);
12818 if (!SWIG_IsOK(ecode3)) {
12819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12820 }
12821 arg3 = static_cast< int >(val3);
12822 }
12823 {
12824 PyThreadState* __tstate = wxPyBeginAllowThreads();
12825 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12826 wxPyEndAllowThreads(__tstate);
12827 if (PyErr_Occurred()) SWIG_fail;
12828 }
12829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12830 {
12831 if (temp1)
12832 delete arg1;
12833 }
12834 return resultobj;
12835 fail:
12836 {
12837 if (temp1)
12838 delete arg1;
12839 }
12840 return NULL;
12841 }
12842
12843
12844 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12845 PyObject *resultobj = 0;
12846 wxImage *arg1 = (wxImage *) 0 ;
12847 void *argp1 = 0 ;
12848 int res1 = 0 ;
12849 PyObject *swig_obj[1] ;
12850
12851 if (!args) SWIG_fail;
12852 swig_obj[0] = args;
12853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12854 if (!SWIG_IsOK(res1)) {
12855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12856 }
12857 arg1 = reinterpret_cast< wxImage * >(argp1);
12858 {
12859 PyThreadState* __tstate = wxPyBeginAllowThreads();
12860 delete arg1;
12861
12862 wxPyEndAllowThreads(__tstate);
12863 if (PyErr_Occurred()) SWIG_fail;
12864 }
12865 resultobj = SWIG_Py_Void();
12866 return resultobj;
12867 fail:
12868 return NULL;
12869 }
12870
12871
12872 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12873 PyObject *resultobj = 0;
12874 wxString *arg1 = 0 ;
12875 wxString *arg2 = 0 ;
12876 int arg3 = (int) -1 ;
12877 wxImage *result = 0 ;
12878 bool temp1 = false ;
12879 bool temp2 = false ;
12880 int val3 ;
12881 int ecode3 = 0 ;
12882 PyObject * obj0 = 0 ;
12883 PyObject * obj1 = 0 ;
12884 PyObject * obj2 = 0 ;
12885 char * kwnames[] = {
12886 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12887 };
12888
12889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12890 {
12891 arg1 = wxString_in_helper(obj0);
12892 if (arg1 == NULL) SWIG_fail;
12893 temp1 = true;
12894 }
12895 {
12896 arg2 = wxString_in_helper(obj1);
12897 if (arg2 == NULL) SWIG_fail;
12898 temp2 = true;
12899 }
12900 if (obj2) {
12901 ecode3 = SWIG_AsVal_int(obj2, &val3);
12902 if (!SWIG_IsOK(ecode3)) {
12903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12904 }
12905 arg3 = static_cast< int >(val3);
12906 }
12907 {
12908 PyThreadState* __tstate = wxPyBeginAllowThreads();
12909 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12910 wxPyEndAllowThreads(__tstate);
12911 if (PyErr_Occurred()) SWIG_fail;
12912 }
12913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12914 {
12915 if (temp1)
12916 delete arg1;
12917 }
12918 {
12919 if (temp2)
12920 delete arg2;
12921 }
12922 return resultobj;
12923 fail:
12924 {
12925 if (temp1)
12926 delete arg1;
12927 }
12928 {
12929 if (temp2)
12930 delete arg2;
12931 }
12932 return NULL;
12933 }
12934
12935
12936 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12937 PyObject *resultobj = 0;
12938 wxInputStream *arg1 = 0 ;
12939 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12940 int arg3 = (int) -1 ;
12941 wxImage *result = 0 ;
12942 wxPyInputStream *temp1 ;
12943 bool created1 ;
12944 long val2 ;
12945 int ecode2 = 0 ;
12946 int val3 ;
12947 int ecode3 = 0 ;
12948 PyObject * obj0 = 0 ;
12949 PyObject * obj1 = 0 ;
12950 PyObject * obj2 = 0 ;
12951 char * kwnames[] = {
12952 (char *) "stream",(char *) "type",(char *) "index", NULL
12953 };
12954
12955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12956 {
12957 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12958 arg1 = temp1->m_wxis;
12959 created1 = false;
12960 } else {
12961 PyErr_Clear(); // clear the failure of the wxPyConvert above
12962 arg1 = wxPyCBInputStream_create(obj0, false);
12963 if (arg1 == NULL) {
12964 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12965 SWIG_fail;
12966 }
12967 created1 = true;
12968 }
12969 }
12970 if (obj1) {
12971 ecode2 = SWIG_AsVal_long(obj1, &val2);
12972 if (!SWIG_IsOK(ecode2)) {
12973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
12974 }
12975 arg2 = static_cast< long >(val2);
12976 }
12977 if (obj2) {
12978 ecode3 = SWIG_AsVal_int(obj2, &val3);
12979 if (!SWIG_IsOK(ecode3)) {
12980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
12981 }
12982 arg3 = static_cast< int >(val3);
12983 }
12984 {
12985 PyThreadState* __tstate = wxPyBeginAllowThreads();
12986 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
12987 wxPyEndAllowThreads(__tstate);
12988 if (PyErr_Occurred()) SWIG_fail;
12989 }
12990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12991 {
12992 if (created1) delete arg1;
12993 }
12994 return resultobj;
12995 fail:
12996 {
12997 if (created1) delete arg1;
12998 }
12999 return NULL;
13000 }
13001
13002
13003 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13004 PyObject *resultobj = 0;
13005 wxInputStream *arg1 = 0 ;
13006 wxString *arg2 = 0 ;
13007 int arg3 = (int) -1 ;
13008 wxImage *result = 0 ;
13009 wxPyInputStream *temp1 ;
13010 bool created1 ;
13011 bool temp2 = false ;
13012 int val3 ;
13013 int ecode3 = 0 ;
13014 PyObject * obj0 = 0 ;
13015 PyObject * obj1 = 0 ;
13016 PyObject * obj2 = 0 ;
13017 char * kwnames[] = {
13018 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13019 };
13020
13021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13022 {
13023 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13024 arg1 = temp1->m_wxis;
13025 created1 = false;
13026 } else {
13027 PyErr_Clear(); // clear the failure of the wxPyConvert above
13028 arg1 = wxPyCBInputStream_create(obj0, false);
13029 if (arg1 == NULL) {
13030 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13031 SWIG_fail;
13032 }
13033 created1 = true;
13034 }
13035 }
13036 {
13037 arg2 = wxString_in_helper(obj1);
13038 if (arg2 == NULL) SWIG_fail;
13039 temp2 = true;
13040 }
13041 if (obj2) {
13042 ecode3 = SWIG_AsVal_int(obj2, &val3);
13043 if (!SWIG_IsOK(ecode3)) {
13044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13045 }
13046 arg3 = static_cast< int >(val3);
13047 }
13048 {
13049 PyThreadState* __tstate = wxPyBeginAllowThreads();
13050 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13051 wxPyEndAllowThreads(__tstate);
13052 if (PyErr_Occurred()) SWIG_fail;
13053 }
13054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13055 {
13056 if (created1) delete arg1;
13057 }
13058 {
13059 if (temp2)
13060 delete arg2;
13061 }
13062 return resultobj;
13063 fail:
13064 {
13065 if (created1) delete arg1;
13066 }
13067 {
13068 if (temp2)
13069 delete arg2;
13070 }
13071 return NULL;
13072 }
13073
13074
13075 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13076 PyObject *resultobj = 0;
13077 int arg1 = (int) 0 ;
13078 int arg2 = (int) 0 ;
13079 bool arg3 = (bool) true ;
13080 wxImage *result = 0 ;
13081 int val1 ;
13082 int ecode1 = 0 ;
13083 int val2 ;
13084 int ecode2 = 0 ;
13085 bool val3 ;
13086 int ecode3 = 0 ;
13087 PyObject * obj0 = 0 ;
13088 PyObject * obj1 = 0 ;
13089 PyObject * obj2 = 0 ;
13090 char * kwnames[] = {
13091 (char *) "width",(char *) "height",(char *) "clear", NULL
13092 };
13093
13094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13095 if (obj0) {
13096 ecode1 = SWIG_AsVal_int(obj0, &val1);
13097 if (!SWIG_IsOK(ecode1)) {
13098 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13099 }
13100 arg1 = static_cast< int >(val1);
13101 }
13102 if (obj1) {
13103 ecode2 = SWIG_AsVal_int(obj1, &val2);
13104 if (!SWIG_IsOK(ecode2)) {
13105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13106 }
13107 arg2 = static_cast< int >(val2);
13108 }
13109 if (obj2) {
13110 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13111 if (!SWIG_IsOK(ecode3)) {
13112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13113 }
13114 arg3 = static_cast< bool >(val3);
13115 }
13116 {
13117 PyThreadState* __tstate = wxPyBeginAllowThreads();
13118 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13119 wxPyEndAllowThreads(__tstate);
13120 if (PyErr_Occurred()) SWIG_fail;
13121 }
13122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13123 return resultobj;
13124 fail:
13125 return NULL;
13126 }
13127
13128
13129 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13130 PyObject *resultobj = 0;
13131 wxBitmap *arg1 = 0 ;
13132 wxImage *result = 0 ;
13133 void *argp1 = 0 ;
13134 int res1 = 0 ;
13135 PyObject * obj0 = 0 ;
13136 char * kwnames[] = {
13137 (char *) "bitmap", NULL
13138 };
13139
13140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13141 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13142 if (!SWIG_IsOK(res1)) {
13143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13144 }
13145 if (!argp1) {
13146 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13147 }
13148 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13149 {
13150 if (!wxPyCheckForApp()) SWIG_fail;
13151 PyThreadState* __tstate = wxPyBeginAllowThreads();
13152 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13153 wxPyEndAllowThreads(__tstate);
13154 if (PyErr_Occurred()) SWIG_fail;
13155 }
13156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13157 return resultobj;
13158 fail:
13159 return NULL;
13160 }
13161
13162
13163 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13164 PyObject *resultobj = 0;
13165 int arg1 ;
13166 int arg2 ;
13167 buffer arg3 ;
13168 int arg4 ;
13169 wxImage *result = 0 ;
13170 int val1 ;
13171 int ecode1 = 0 ;
13172 int val2 ;
13173 int ecode2 = 0 ;
13174 PyObject * obj0 = 0 ;
13175 PyObject * obj1 = 0 ;
13176 PyObject * obj2 = 0 ;
13177 char * kwnames[] = {
13178 (char *) "width",(char *) "height",(char *) "data", NULL
13179 };
13180
13181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13182 ecode1 = SWIG_AsVal_int(obj0, &val1);
13183 if (!SWIG_IsOK(ecode1)) {
13184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13185 }
13186 arg1 = static_cast< int >(val1);
13187 ecode2 = SWIG_AsVal_int(obj1, &val2);
13188 if (!SWIG_IsOK(ecode2)) {
13189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13190 }
13191 arg2 = static_cast< int >(val2);
13192 {
13193 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13194 }
13195 {
13196 PyThreadState* __tstate = wxPyBeginAllowThreads();
13197 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13198 wxPyEndAllowThreads(__tstate);
13199 if (PyErr_Occurred()) SWIG_fail;
13200 }
13201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13202 return resultobj;
13203 fail:
13204 return NULL;
13205 }
13206
13207
13208 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13209 PyObject *resultobj = 0;
13210 int arg1 ;
13211 int arg2 ;
13212 buffer arg3 ;
13213 int arg4 ;
13214 buffer arg5 ;
13215 int arg6 ;
13216 wxImage *result = 0 ;
13217 int val1 ;
13218 int ecode1 = 0 ;
13219 int val2 ;
13220 int ecode2 = 0 ;
13221 PyObject * obj0 = 0 ;
13222 PyObject * obj1 = 0 ;
13223 PyObject * obj2 = 0 ;
13224 PyObject * obj3 = 0 ;
13225 char * kwnames[] = {
13226 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13227 };
13228
13229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13230 ecode1 = SWIG_AsVal_int(obj0, &val1);
13231 if (!SWIG_IsOK(ecode1)) {
13232 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13233 }
13234 arg1 = static_cast< int >(val1);
13235 ecode2 = SWIG_AsVal_int(obj1, &val2);
13236 if (!SWIG_IsOK(ecode2)) {
13237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13238 }
13239 arg2 = static_cast< int >(val2);
13240 {
13241 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13242 }
13243 {
13244 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13245 }
13246 {
13247 PyThreadState* __tstate = wxPyBeginAllowThreads();
13248 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13249 wxPyEndAllowThreads(__tstate);
13250 if (PyErr_Occurred()) SWIG_fail;
13251 }
13252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13253 return resultobj;
13254 fail:
13255 return NULL;
13256 }
13257
13258
13259 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13260 PyObject *resultobj = 0;
13261 wxImage *arg1 = (wxImage *) 0 ;
13262 int arg2 ;
13263 int arg3 ;
13264 bool arg4 = (bool) true ;
13265 void *argp1 = 0 ;
13266 int res1 = 0 ;
13267 int val2 ;
13268 int ecode2 = 0 ;
13269 int val3 ;
13270 int ecode3 = 0 ;
13271 bool val4 ;
13272 int ecode4 = 0 ;
13273 PyObject * obj0 = 0 ;
13274 PyObject * obj1 = 0 ;
13275 PyObject * obj2 = 0 ;
13276 PyObject * obj3 = 0 ;
13277 char * kwnames[] = {
13278 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13279 };
13280
13281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13283 if (!SWIG_IsOK(res1)) {
13284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13285 }
13286 arg1 = reinterpret_cast< wxImage * >(argp1);
13287 ecode2 = SWIG_AsVal_int(obj1, &val2);
13288 if (!SWIG_IsOK(ecode2)) {
13289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13290 }
13291 arg2 = static_cast< int >(val2);
13292 ecode3 = SWIG_AsVal_int(obj2, &val3);
13293 if (!SWIG_IsOK(ecode3)) {
13294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13295 }
13296 arg3 = static_cast< int >(val3);
13297 if (obj3) {
13298 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13299 if (!SWIG_IsOK(ecode4)) {
13300 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13301 }
13302 arg4 = static_cast< bool >(val4);
13303 }
13304 {
13305 PyThreadState* __tstate = wxPyBeginAllowThreads();
13306 (arg1)->Create(arg2,arg3,arg4);
13307 wxPyEndAllowThreads(__tstate);
13308 if (PyErr_Occurred()) SWIG_fail;
13309 }
13310 resultobj = SWIG_Py_Void();
13311 return resultobj;
13312 fail:
13313 return NULL;
13314 }
13315
13316
13317 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13318 PyObject *resultobj = 0;
13319 wxImage *arg1 = (wxImage *) 0 ;
13320 void *argp1 = 0 ;
13321 int res1 = 0 ;
13322 PyObject *swig_obj[1] ;
13323
13324 if (!args) SWIG_fail;
13325 swig_obj[0] = args;
13326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13327 if (!SWIG_IsOK(res1)) {
13328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13329 }
13330 arg1 = reinterpret_cast< wxImage * >(argp1);
13331 {
13332 PyThreadState* __tstate = wxPyBeginAllowThreads();
13333 (arg1)->Destroy();
13334 wxPyEndAllowThreads(__tstate);
13335 if (PyErr_Occurred()) SWIG_fail;
13336 }
13337 resultobj = SWIG_Py_Void();
13338 return resultobj;
13339 fail:
13340 return NULL;
13341 }
13342
13343
13344 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13345 PyObject *resultobj = 0;
13346 wxImage *arg1 = (wxImage *) 0 ;
13347 int arg2 ;
13348 int arg3 ;
13349 SwigValueWrapper<wxImage > result;
13350 void *argp1 = 0 ;
13351 int res1 = 0 ;
13352 int val2 ;
13353 int ecode2 = 0 ;
13354 int val3 ;
13355 int ecode3 = 0 ;
13356 PyObject * obj0 = 0 ;
13357 PyObject * obj1 = 0 ;
13358 PyObject * obj2 = 0 ;
13359 char * kwnames[] = {
13360 (char *) "self",(char *) "width",(char *) "height", NULL
13361 };
13362
13363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13365 if (!SWIG_IsOK(res1)) {
13366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13367 }
13368 arg1 = reinterpret_cast< wxImage * >(argp1);
13369 ecode2 = SWIG_AsVal_int(obj1, &val2);
13370 if (!SWIG_IsOK(ecode2)) {
13371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13372 }
13373 arg2 = static_cast< int >(val2);
13374 ecode3 = SWIG_AsVal_int(obj2, &val3);
13375 if (!SWIG_IsOK(ecode3)) {
13376 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13377 }
13378 arg3 = static_cast< int >(val3);
13379 {
13380 PyThreadState* __tstate = wxPyBeginAllowThreads();
13381 result = (arg1)->Scale(arg2,arg3);
13382 wxPyEndAllowThreads(__tstate);
13383 if (PyErr_Occurred()) SWIG_fail;
13384 }
13385 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13386 return resultobj;
13387 fail:
13388 return NULL;
13389 }
13390
13391
13392 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13393 PyObject *resultobj = 0;
13394 wxImage *arg1 = (wxImage *) 0 ;
13395 int arg2 ;
13396 int arg3 ;
13397 SwigValueWrapper<wxImage > result;
13398 void *argp1 = 0 ;
13399 int res1 = 0 ;
13400 int val2 ;
13401 int ecode2 = 0 ;
13402 int val3 ;
13403 int ecode3 = 0 ;
13404 PyObject * obj0 = 0 ;
13405 PyObject * obj1 = 0 ;
13406 PyObject * obj2 = 0 ;
13407 char * kwnames[] = {
13408 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13409 };
13410
13411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13413 if (!SWIG_IsOK(res1)) {
13414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13415 }
13416 arg1 = reinterpret_cast< wxImage * >(argp1);
13417 ecode2 = SWIG_AsVal_int(obj1, &val2);
13418 if (!SWIG_IsOK(ecode2)) {
13419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13420 }
13421 arg2 = static_cast< int >(val2);
13422 ecode3 = SWIG_AsVal_int(obj2, &val3);
13423 if (!SWIG_IsOK(ecode3)) {
13424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13425 }
13426 arg3 = static_cast< int >(val3);
13427 {
13428 PyThreadState* __tstate = wxPyBeginAllowThreads();
13429 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13430 wxPyEndAllowThreads(__tstate);
13431 if (PyErr_Occurred()) SWIG_fail;
13432 }
13433 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13434 return resultobj;
13435 fail:
13436 return NULL;
13437 }
13438
13439
13440 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13441 PyObject *resultobj = 0;
13442 wxImage *arg1 = (wxImage *) 0 ;
13443 int arg2 ;
13444 int arg3 ;
13445 wxImage *result = 0 ;
13446 void *argp1 = 0 ;
13447 int res1 = 0 ;
13448 int val2 ;
13449 int ecode2 = 0 ;
13450 int val3 ;
13451 int ecode3 = 0 ;
13452 PyObject * obj0 = 0 ;
13453 PyObject * obj1 = 0 ;
13454 PyObject * obj2 = 0 ;
13455 char * kwnames[] = {
13456 (char *) "self",(char *) "width",(char *) "height", NULL
13457 };
13458
13459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13461 if (!SWIG_IsOK(res1)) {
13462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13463 }
13464 arg1 = reinterpret_cast< wxImage * >(argp1);
13465 ecode2 = SWIG_AsVal_int(obj1, &val2);
13466 if (!SWIG_IsOK(ecode2)) {
13467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13468 }
13469 arg2 = static_cast< int >(val2);
13470 ecode3 = SWIG_AsVal_int(obj2, &val3);
13471 if (!SWIG_IsOK(ecode3)) {
13472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13473 }
13474 arg3 = static_cast< int >(val3);
13475 {
13476 PyThreadState* __tstate = wxPyBeginAllowThreads();
13477 {
13478 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13479 result = (wxImage *) &_result_ref;
13480 }
13481 wxPyEndAllowThreads(__tstate);
13482 if (PyErr_Occurred()) SWIG_fail;
13483 }
13484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13485 return resultobj;
13486 fail:
13487 return NULL;
13488 }
13489
13490
13491 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13492 PyObject *resultobj = 0;
13493 wxImage *arg1 = (wxImage *) 0 ;
13494 wxSize *arg2 = 0 ;
13495 wxPoint *arg3 = 0 ;
13496 int arg4 = (int) -1 ;
13497 int arg5 = (int) -1 ;
13498 int arg6 = (int) -1 ;
13499 wxImage *result = 0 ;
13500 void *argp1 = 0 ;
13501 int res1 = 0 ;
13502 wxSize temp2 ;
13503 wxPoint temp3 ;
13504 int val4 ;
13505 int ecode4 = 0 ;
13506 int val5 ;
13507 int ecode5 = 0 ;
13508 int val6 ;
13509 int ecode6 = 0 ;
13510 PyObject * obj0 = 0 ;
13511 PyObject * obj1 = 0 ;
13512 PyObject * obj2 = 0 ;
13513 PyObject * obj3 = 0 ;
13514 PyObject * obj4 = 0 ;
13515 PyObject * obj5 = 0 ;
13516 char * kwnames[] = {
13517 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13518 };
13519
13520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13522 if (!SWIG_IsOK(res1)) {
13523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13524 }
13525 arg1 = reinterpret_cast< wxImage * >(argp1);
13526 {
13527 arg2 = &temp2;
13528 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13529 }
13530 {
13531 arg3 = &temp3;
13532 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13533 }
13534 if (obj3) {
13535 ecode4 = SWIG_AsVal_int(obj3, &val4);
13536 if (!SWIG_IsOK(ecode4)) {
13537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13538 }
13539 arg4 = static_cast< int >(val4);
13540 }
13541 if (obj4) {
13542 ecode5 = SWIG_AsVal_int(obj4, &val5);
13543 if (!SWIG_IsOK(ecode5)) {
13544 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13545 }
13546 arg5 = static_cast< int >(val5);
13547 }
13548 if (obj5) {
13549 ecode6 = SWIG_AsVal_int(obj5, &val6);
13550 if (!SWIG_IsOK(ecode6)) {
13551 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13552 }
13553 arg6 = static_cast< int >(val6);
13554 }
13555 {
13556 PyThreadState* __tstate = wxPyBeginAllowThreads();
13557 {
13558 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13559 result = (wxImage *) &_result_ref;
13560 }
13561 wxPyEndAllowThreads(__tstate);
13562 if (PyErr_Occurred()) SWIG_fail;
13563 }
13564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13565 return resultobj;
13566 fail:
13567 return NULL;
13568 }
13569
13570
13571 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13572 PyObject *resultobj = 0;
13573 wxImage *arg1 = (wxImage *) 0 ;
13574 int arg2 ;
13575 int arg3 ;
13576 byte arg4 ;
13577 byte arg5 ;
13578 byte arg6 ;
13579 void *argp1 = 0 ;
13580 int res1 = 0 ;
13581 int val2 ;
13582 int ecode2 = 0 ;
13583 int val3 ;
13584 int ecode3 = 0 ;
13585 unsigned char val4 ;
13586 int ecode4 = 0 ;
13587 unsigned char val5 ;
13588 int ecode5 = 0 ;
13589 unsigned char val6 ;
13590 int ecode6 = 0 ;
13591 PyObject * obj0 = 0 ;
13592 PyObject * obj1 = 0 ;
13593 PyObject * obj2 = 0 ;
13594 PyObject * obj3 = 0 ;
13595 PyObject * obj4 = 0 ;
13596 PyObject * obj5 = 0 ;
13597 char * kwnames[] = {
13598 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13599 };
13600
13601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13603 if (!SWIG_IsOK(res1)) {
13604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13605 }
13606 arg1 = reinterpret_cast< wxImage * >(argp1);
13607 ecode2 = SWIG_AsVal_int(obj1, &val2);
13608 if (!SWIG_IsOK(ecode2)) {
13609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13610 }
13611 arg2 = static_cast< int >(val2);
13612 ecode3 = SWIG_AsVal_int(obj2, &val3);
13613 if (!SWIG_IsOK(ecode3)) {
13614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13615 }
13616 arg3 = static_cast< int >(val3);
13617 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13618 if (!SWIG_IsOK(ecode4)) {
13619 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13620 }
13621 arg4 = static_cast< byte >(val4);
13622 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13623 if (!SWIG_IsOK(ecode5)) {
13624 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13625 }
13626 arg5 = static_cast< byte >(val5);
13627 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13628 if (!SWIG_IsOK(ecode6)) {
13629 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13630 }
13631 arg6 = static_cast< byte >(val6);
13632 {
13633 PyThreadState* __tstate = wxPyBeginAllowThreads();
13634 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13635 wxPyEndAllowThreads(__tstate);
13636 if (PyErr_Occurred()) SWIG_fail;
13637 }
13638 resultobj = SWIG_Py_Void();
13639 return resultobj;
13640 fail:
13641 return NULL;
13642 }
13643
13644
13645 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13646 PyObject *resultobj = 0;
13647 wxImage *arg1 = (wxImage *) 0 ;
13648 wxRect *arg2 = 0 ;
13649 byte arg3 ;
13650 byte arg4 ;
13651 byte arg5 ;
13652 void *argp1 = 0 ;
13653 int res1 = 0 ;
13654 wxRect temp2 ;
13655 unsigned char val3 ;
13656 int ecode3 = 0 ;
13657 unsigned char val4 ;
13658 int ecode4 = 0 ;
13659 unsigned char val5 ;
13660 int ecode5 = 0 ;
13661 PyObject * obj0 = 0 ;
13662 PyObject * obj1 = 0 ;
13663 PyObject * obj2 = 0 ;
13664 PyObject * obj3 = 0 ;
13665 PyObject * obj4 = 0 ;
13666 char * kwnames[] = {
13667 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13668 };
13669
13670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13672 if (!SWIG_IsOK(res1)) {
13673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13674 }
13675 arg1 = reinterpret_cast< wxImage * >(argp1);
13676 {
13677 arg2 = &temp2;
13678 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13679 }
13680 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13681 if (!SWIG_IsOK(ecode3)) {
13682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13683 }
13684 arg3 = static_cast< byte >(val3);
13685 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13686 if (!SWIG_IsOK(ecode4)) {
13687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13688 }
13689 arg4 = static_cast< byte >(val4);
13690 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13691 if (!SWIG_IsOK(ecode5)) {
13692 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13693 }
13694 arg5 = static_cast< byte >(val5);
13695 {
13696 PyThreadState* __tstate = wxPyBeginAllowThreads();
13697 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13698 wxPyEndAllowThreads(__tstate);
13699 if (PyErr_Occurred()) SWIG_fail;
13700 }
13701 resultobj = SWIG_Py_Void();
13702 return resultobj;
13703 fail:
13704 return NULL;
13705 }
13706
13707
13708 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13709 PyObject *resultobj = 0;
13710 wxImage *arg1 = (wxImage *) 0 ;
13711 int arg2 ;
13712 int arg3 ;
13713 byte result;
13714 void *argp1 = 0 ;
13715 int res1 = 0 ;
13716 int val2 ;
13717 int ecode2 = 0 ;
13718 int val3 ;
13719 int ecode3 = 0 ;
13720 PyObject * obj0 = 0 ;
13721 PyObject * obj1 = 0 ;
13722 PyObject * obj2 = 0 ;
13723 char * kwnames[] = {
13724 (char *) "self",(char *) "x",(char *) "y", NULL
13725 };
13726
13727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13729 if (!SWIG_IsOK(res1)) {
13730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13731 }
13732 arg1 = reinterpret_cast< wxImage * >(argp1);
13733 ecode2 = SWIG_AsVal_int(obj1, &val2);
13734 if (!SWIG_IsOK(ecode2)) {
13735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13736 }
13737 arg2 = static_cast< int >(val2);
13738 ecode3 = SWIG_AsVal_int(obj2, &val3);
13739 if (!SWIG_IsOK(ecode3)) {
13740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13741 }
13742 arg3 = static_cast< int >(val3);
13743 {
13744 PyThreadState* __tstate = wxPyBeginAllowThreads();
13745 result = (byte)(arg1)->GetRed(arg2,arg3);
13746 wxPyEndAllowThreads(__tstate);
13747 if (PyErr_Occurred()) SWIG_fail;
13748 }
13749 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13750 return resultobj;
13751 fail:
13752 return NULL;
13753 }
13754
13755
13756 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13757 PyObject *resultobj = 0;
13758 wxImage *arg1 = (wxImage *) 0 ;
13759 int arg2 ;
13760 int arg3 ;
13761 byte result;
13762 void *argp1 = 0 ;
13763 int res1 = 0 ;
13764 int val2 ;
13765 int ecode2 = 0 ;
13766 int val3 ;
13767 int ecode3 = 0 ;
13768 PyObject * obj0 = 0 ;
13769 PyObject * obj1 = 0 ;
13770 PyObject * obj2 = 0 ;
13771 char * kwnames[] = {
13772 (char *) "self",(char *) "x",(char *) "y", NULL
13773 };
13774
13775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13777 if (!SWIG_IsOK(res1)) {
13778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13779 }
13780 arg1 = reinterpret_cast< wxImage * >(argp1);
13781 ecode2 = SWIG_AsVal_int(obj1, &val2);
13782 if (!SWIG_IsOK(ecode2)) {
13783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13784 }
13785 arg2 = static_cast< int >(val2);
13786 ecode3 = SWIG_AsVal_int(obj2, &val3);
13787 if (!SWIG_IsOK(ecode3)) {
13788 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13789 }
13790 arg3 = static_cast< int >(val3);
13791 {
13792 PyThreadState* __tstate = wxPyBeginAllowThreads();
13793 result = (byte)(arg1)->GetGreen(arg2,arg3);
13794 wxPyEndAllowThreads(__tstate);
13795 if (PyErr_Occurred()) SWIG_fail;
13796 }
13797 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13798 return resultobj;
13799 fail:
13800 return NULL;
13801 }
13802
13803
13804 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13805 PyObject *resultobj = 0;
13806 wxImage *arg1 = (wxImage *) 0 ;
13807 int arg2 ;
13808 int arg3 ;
13809 byte result;
13810 void *argp1 = 0 ;
13811 int res1 = 0 ;
13812 int val2 ;
13813 int ecode2 = 0 ;
13814 int val3 ;
13815 int ecode3 = 0 ;
13816 PyObject * obj0 = 0 ;
13817 PyObject * obj1 = 0 ;
13818 PyObject * obj2 = 0 ;
13819 char * kwnames[] = {
13820 (char *) "self",(char *) "x",(char *) "y", NULL
13821 };
13822
13823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13825 if (!SWIG_IsOK(res1)) {
13826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13827 }
13828 arg1 = reinterpret_cast< wxImage * >(argp1);
13829 ecode2 = SWIG_AsVal_int(obj1, &val2);
13830 if (!SWIG_IsOK(ecode2)) {
13831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13832 }
13833 arg2 = static_cast< int >(val2);
13834 ecode3 = SWIG_AsVal_int(obj2, &val3);
13835 if (!SWIG_IsOK(ecode3)) {
13836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13837 }
13838 arg3 = static_cast< int >(val3);
13839 {
13840 PyThreadState* __tstate = wxPyBeginAllowThreads();
13841 result = (byte)(arg1)->GetBlue(arg2,arg3);
13842 wxPyEndAllowThreads(__tstate);
13843 if (PyErr_Occurred()) SWIG_fail;
13844 }
13845 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13846 return resultobj;
13847 fail:
13848 return NULL;
13849 }
13850
13851
13852 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13853 PyObject *resultobj = 0;
13854 wxImage *arg1 = (wxImage *) 0 ;
13855 int arg2 ;
13856 int arg3 ;
13857 byte arg4 ;
13858 void *argp1 = 0 ;
13859 int res1 = 0 ;
13860 int val2 ;
13861 int ecode2 = 0 ;
13862 int val3 ;
13863 int ecode3 = 0 ;
13864 unsigned char val4 ;
13865 int ecode4 = 0 ;
13866 PyObject * obj0 = 0 ;
13867 PyObject * obj1 = 0 ;
13868 PyObject * obj2 = 0 ;
13869 PyObject * obj3 = 0 ;
13870 char * kwnames[] = {
13871 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13872 };
13873
13874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13876 if (!SWIG_IsOK(res1)) {
13877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13878 }
13879 arg1 = reinterpret_cast< wxImage * >(argp1);
13880 ecode2 = SWIG_AsVal_int(obj1, &val2);
13881 if (!SWIG_IsOK(ecode2)) {
13882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13883 }
13884 arg2 = static_cast< int >(val2);
13885 ecode3 = SWIG_AsVal_int(obj2, &val3);
13886 if (!SWIG_IsOK(ecode3)) {
13887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13888 }
13889 arg3 = static_cast< int >(val3);
13890 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13891 if (!SWIG_IsOK(ecode4)) {
13892 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13893 }
13894 arg4 = static_cast< byte >(val4);
13895 {
13896 PyThreadState* __tstate = wxPyBeginAllowThreads();
13897 (arg1)->SetAlpha(arg2,arg3,arg4);
13898 wxPyEndAllowThreads(__tstate);
13899 if (PyErr_Occurred()) SWIG_fail;
13900 }
13901 resultobj = SWIG_Py_Void();
13902 return resultobj;
13903 fail:
13904 return NULL;
13905 }
13906
13907
13908 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13909 PyObject *resultobj = 0;
13910 wxImage *arg1 = (wxImage *) 0 ;
13911 int arg2 ;
13912 int arg3 ;
13913 byte result;
13914 void *argp1 = 0 ;
13915 int res1 = 0 ;
13916 int val2 ;
13917 int ecode2 = 0 ;
13918 int val3 ;
13919 int ecode3 = 0 ;
13920 PyObject * obj0 = 0 ;
13921 PyObject * obj1 = 0 ;
13922 PyObject * obj2 = 0 ;
13923 char * kwnames[] = {
13924 (char *) "self",(char *) "x",(char *) "y", NULL
13925 };
13926
13927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13929 if (!SWIG_IsOK(res1)) {
13930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13931 }
13932 arg1 = reinterpret_cast< wxImage * >(argp1);
13933 ecode2 = SWIG_AsVal_int(obj1, &val2);
13934 if (!SWIG_IsOK(ecode2)) {
13935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13936 }
13937 arg2 = static_cast< int >(val2);
13938 ecode3 = SWIG_AsVal_int(obj2, &val3);
13939 if (!SWIG_IsOK(ecode3)) {
13940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
13941 }
13942 arg3 = static_cast< int >(val3);
13943 {
13944 PyThreadState* __tstate = wxPyBeginAllowThreads();
13945 result = (byte)(arg1)->GetAlpha(arg2,arg3);
13946 wxPyEndAllowThreads(__tstate);
13947 if (PyErr_Occurred()) SWIG_fail;
13948 }
13949 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13950 return resultobj;
13951 fail:
13952 return NULL;
13953 }
13954
13955
13956 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13957 PyObject *resultobj = 0;
13958 wxImage *arg1 = (wxImage *) 0 ;
13959 bool result;
13960 void *argp1 = 0 ;
13961 int res1 = 0 ;
13962 PyObject *swig_obj[1] ;
13963
13964 if (!args) SWIG_fail;
13965 swig_obj[0] = args;
13966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13967 if (!SWIG_IsOK(res1)) {
13968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13969 }
13970 arg1 = reinterpret_cast< wxImage * >(argp1);
13971 {
13972 PyThreadState* __tstate = wxPyBeginAllowThreads();
13973 result = (bool)(arg1)->HasAlpha();
13974 wxPyEndAllowThreads(__tstate);
13975 if (PyErr_Occurred()) SWIG_fail;
13976 }
13977 {
13978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13979 }
13980 return resultobj;
13981 fail:
13982 return NULL;
13983 }
13984
13985
13986 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13987 PyObject *resultobj = 0;
13988 wxImage *arg1 = (wxImage *) 0 ;
13989 void *argp1 = 0 ;
13990 int res1 = 0 ;
13991 PyObject *swig_obj[1] ;
13992
13993 if (!args) SWIG_fail;
13994 swig_obj[0] = args;
13995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13996 if (!SWIG_IsOK(res1)) {
13997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13998 }
13999 arg1 = reinterpret_cast< wxImage * >(argp1);
14000 {
14001 PyThreadState* __tstate = wxPyBeginAllowThreads();
14002 (arg1)->InitAlpha();
14003 wxPyEndAllowThreads(__tstate);
14004 if (PyErr_Occurred()) SWIG_fail;
14005 }
14006 resultobj = SWIG_Py_Void();
14007 return resultobj;
14008 fail:
14009 return NULL;
14010 }
14011
14012
14013 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14014 PyObject *resultobj = 0;
14015 wxImage *arg1 = (wxImage *) 0 ;
14016 int arg2 ;
14017 int arg3 ;
14018 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14019 bool result;
14020 void *argp1 = 0 ;
14021 int res1 = 0 ;
14022 int val2 ;
14023 int ecode2 = 0 ;
14024 int val3 ;
14025 int ecode3 = 0 ;
14026 unsigned char val4 ;
14027 int ecode4 = 0 ;
14028 PyObject * obj0 = 0 ;
14029 PyObject * obj1 = 0 ;
14030 PyObject * obj2 = 0 ;
14031 PyObject * obj3 = 0 ;
14032 char * kwnames[] = {
14033 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14034 };
14035
14036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14038 if (!SWIG_IsOK(res1)) {
14039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14040 }
14041 arg1 = reinterpret_cast< wxImage * >(argp1);
14042 ecode2 = SWIG_AsVal_int(obj1, &val2);
14043 if (!SWIG_IsOK(ecode2)) {
14044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14045 }
14046 arg2 = static_cast< int >(val2);
14047 ecode3 = SWIG_AsVal_int(obj2, &val3);
14048 if (!SWIG_IsOK(ecode3)) {
14049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14050 }
14051 arg3 = static_cast< int >(val3);
14052 if (obj3) {
14053 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14054 if (!SWIG_IsOK(ecode4)) {
14055 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14056 }
14057 arg4 = static_cast< byte >(val4);
14058 }
14059 {
14060 PyThreadState* __tstate = wxPyBeginAllowThreads();
14061 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14062 wxPyEndAllowThreads(__tstate);
14063 if (PyErr_Occurred()) SWIG_fail;
14064 }
14065 {
14066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14067 }
14068 return resultobj;
14069 fail:
14070 return NULL;
14071 }
14072
14073
14074 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj = 0;
14076 wxImage *arg1 = (wxImage *) 0 ;
14077 byte *arg2 = (byte *) 0 ;
14078 byte *arg3 = (byte *) 0 ;
14079 byte *arg4 = (byte *) 0 ;
14080 byte arg5 = (byte) 0 ;
14081 byte arg6 = (byte) 0 ;
14082 byte arg7 = (byte) 0 ;
14083 bool result;
14084 void *argp1 = 0 ;
14085 int res1 = 0 ;
14086 byte temp2 ;
14087 int res2 = SWIG_TMPOBJ ;
14088 byte temp3 ;
14089 int res3 = SWIG_TMPOBJ ;
14090 byte temp4 ;
14091 int res4 = SWIG_TMPOBJ ;
14092 unsigned char val5 ;
14093 int ecode5 = 0 ;
14094 unsigned char val6 ;
14095 int ecode6 = 0 ;
14096 unsigned char val7 ;
14097 int ecode7 = 0 ;
14098 PyObject * obj0 = 0 ;
14099 PyObject * obj1 = 0 ;
14100 PyObject * obj2 = 0 ;
14101 PyObject * obj3 = 0 ;
14102 char * kwnames[] = {
14103 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14104 };
14105
14106 arg2 = &temp2;
14107 arg3 = &temp3;
14108 arg4 = &temp4;
14109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14111 if (!SWIG_IsOK(res1)) {
14112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14113 }
14114 arg1 = reinterpret_cast< wxImage * >(argp1);
14115 if (obj1) {
14116 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14117 if (!SWIG_IsOK(ecode5)) {
14118 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14119 }
14120 arg5 = static_cast< byte >(val5);
14121 }
14122 if (obj2) {
14123 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14124 if (!SWIG_IsOK(ecode6)) {
14125 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14126 }
14127 arg6 = static_cast< byte >(val6);
14128 }
14129 if (obj3) {
14130 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14131 if (!SWIG_IsOK(ecode7)) {
14132 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14133 }
14134 arg7 = static_cast< byte >(val7);
14135 }
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14139 wxPyEndAllowThreads(__tstate);
14140 if (PyErr_Occurred()) SWIG_fail;
14141 }
14142 {
14143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14144 }
14145 if (SWIG_IsTmpObj(res2)) {
14146 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14147 } else {
14148 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14149 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14150 }
14151 if (SWIG_IsTmpObj(res3)) {
14152 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14153 } else {
14154 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14155 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14156 }
14157 if (SWIG_IsTmpObj(res4)) {
14158 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14159 } else {
14160 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14161 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14162 }
14163 return resultobj;
14164 fail:
14165 return NULL;
14166 }
14167
14168
14169 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14170 PyObject *resultobj = 0;
14171 wxImage *arg1 = (wxImage *) 0 ;
14172 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14173 bool result;
14174 void *argp1 = 0 ;
14175 int res1 = 0 ;
14176 unsigned char val2 ;
14177 int ecode2 = 0 ;
14178 PyObject * obj0 = 0 ;
14179 PyObject * obj1 = 0 ;
14180 char * kwnames[] = {
14181 (char *) "self",(char *) "threshold", NULL
14182 };
14183
14184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14186 if (!SWIG_IsOK(res1)) {
14187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14188 }
14189 arg1 = reinterpret_cast< wxImage * >(argp1);
14190 if (obj1) {
14191 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14192 if (!SWIG_IsOK(ecode2)) {
14193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14194 }
14195 arg2 = static_cast< byte >(val2);
14196 }
14197 {
14198 PyThreadState* __tstate = wxPyBeginAllowThreads();
14199 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14200 wxPyEndAllowThreads(__tstate);
14201 if (PyErr_Occurred()) SWIG_fail;
14202 }
14203 {
14204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14205 }
14206 return resultobj;
14207 fail:
14208 return NULL;
14209 }
14210
14211
14212 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14213 PyObject *resultobj = 0;
14214 wxImage *arg1 = (wxImage *) 0 ;
14215 byte arg2 ;
14216 byte arg3 ;
14217 byte arg4 ;
14218 bool result;
14219 void *argp1 = 0 ;
14220 int res1 = 0 ;
14221 unsigned char val2 ;
14222 int ecode2 = 0 ;
14223 unsigned char val3 ;
14224 int ecode3 = 0 ;
14225 unsigned char val4 ;
14226 int ecode4 = 0 ;
14227 PyObject * obj0 = 0 ;
14228 PyObject * obj1 = 0 ;
14229 PyObject * obj2 = 0 ;
14230 PyObject * obj3 = 0 ;
14231 char * kwnames[] = {
14232 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14233 };
14234
14235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14237 if (!SWIG_IsOK(res1)) {
14238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14239 }
14240 arg1 = reinterpret_cast< wxImage * >(argp1);
14241 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14242 if (!SWIG_IsOK(ecode2)) {
14243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14244 }
14245 arg2 = static_cast< byte >(val2);
14246 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14247 if (!SWIG_IsOK(ecode3)) {
14248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14249 }
14250 arg3 = static_cast< byte >(val3);
14251 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14252 if (!SWIG_IsOK(ecode4)) {
14253 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14254 }
14255 arg4 = static_cast< byte >(val4);
14256 {
14257 PyThreadState* __tstate = wxPyBeginAllowThreads();
14258 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14259 wxPyEndAllowThreads(__tstate);
14260 if (PyErr_Occurred()) SWIG_fail;
14261 }
14262 {
14263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14264 }
14265 return resultobj;
14266 fail:
14267 return NULL;
14268 }
14269
14270
14271 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14272 PyObject *resultobj = 0;
14273 wxImage *arg1 = (wxImage *) 0 ;
14274 wxImage *arg2 = 0 ;
14275 byte arg3 ;
14276 byte arg4 ;
14277 byte arg5 ;
14278 bool result;
14279 void *argp1 = 0 ;
14280 int res1 = 0 ;
14281 void *argp2 = 0 ;
14282 int res2 = 0 ;
14283 unsigned char val3 ;
14284 int ecode3 = 0 ;
14285 unsigned char val4 ;
14286 int ecode4 = 0 ;
14287 unsigned char val5 ;
14288 int ecode5 = 0 ;
14289 PyObject * obj0 = 0 ;
14290 PyObject * obj1 = 0 ;
14291 PyObject * obj2 = 0 ;
14292 PyObject * obj3 = 0 ;
14293 PyObject * obj4 = 0 ;
14294 char * kwnames[] = {
14295 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14296 };
14297
14298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14300 if (!SWIG_IsOK(res1)) {
14301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14302 }
14303 arg1 = reinterpret_cast< wxImage * >(argp1);
14304 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14305 if (!SWIG_IsOK(res2)) {
14306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14307 }
14308 if (!argp2) {
14309 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14310 }
14311 arg2 = reinterpret_cast< wxImage * >(argp2);
14312 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14313 if (!SWIG_IsOK(ecode3)) {
14314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14315 }
14316 arg3 = static_cast< byte >(val3);
14317 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14318 if (!SWIG_IsOK(ecode4)) {
14319 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14320 }
14321 arg4 = static_cast< byte >(val4);
14322 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14323 if (!SWIG_IsOK(ecode5)) {
14324 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14325 }
14326 arg5 = static_cast< byte >(val5);
14327 {
14328 PyThreadState* __tstate = wxPyBeginAllowThreads();
14329 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14330 wxPyEndAllowThreads(__tstate);
14331 if (PyErr_Occurred()) SWIG_fail;
14332 }
14333 {
14334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14335 }
14336 return resultobj;
14337 fail:
14338 return NULL;
14339 }
14340
14341
14342 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14343 PyObject *resultobj = 0;
14344 wxString *arg1 = 0 ;
14345 bool result;
14346 bool temp1 = false ;
14347 PyObject * obj0 = 0 ;
14348 char * kwnames[] = {
14349 (char *) "filename", NULL
14350 };
14351
14352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14353 {
14354 arg1 = wxString_in_helper(obj0);
14355 if (arg1 == NULL) SWIG_fail;
14356 temp1 = true;
14357 }
14358 {
14359 PyThreadState* __tstate = wxPyBeginAllowThreads();
14360 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14361 wxPyEndAllowThreads(__tstate);
14362 if (PyErr_Occurred()) SWIG_fail;
14363 }
14364 {
14365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14366 }
14367 {
14368 if (temp1)
14369 delete arg1;
14370 }
14371 return resultobj;
14372 fail:
14373 {
14374 if (temp1)
14375 delete arg1;
14376 }
14377 return NULL;
14378 }
14379
14380
14381 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14382 PyObject *resultobj = 0;
14383 wxString *arg1 = 0 ;
14384 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14385 int result;
14386 bool temp1 = false ;
14387 long val2 ;
14388 int ecode2 = 0 ;
14389 PyObject * obj0 = 0 ;
14390 PyObject * obj1 = 0 ;
14391 char * kwnames[] = {
14392 (char *) "filename",(char *) "type", NULL
14393 };
14394
14395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14396 {
14397 arg1 = wxString_in_helper(obj0);
14398 if (arg1 == NULL) SWIG_fail;
14399 temp1 = true;
14400 }
14401 if (obj1) {
14402 ecode2 = SWIG_AsVal_long(obj1, &val2);
14403 if (!SWIG_IsOK(ecode2)) {
14404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14405 }
14406 arg2 = static_cast< long >(val2);
14407 }
14408 {
14409 PyThreadState* __tstate = wxPyBeginAllowThreads();
14410 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14411 wxPyEndAllowThreads(__tstate);
14412 if (PyErr_Occurred()) SWIG_fail;
14413 }
14414 resultobj = SWIG_From_int(static_cast< int >(result));
14415 {
14416 if (temp1)
14417 delete arg1;
14418 }
14419 return resultobj;
14420 fail:
14421 {
14422 if (temp1)
14423 delete arg1;
14424 }
14425 return NULL;
14426 }
14427
14428
14429 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14430 PyObject *resultobj = 0;
14431 wxImage *arg1 = (wxImage *) 0 ;
14432 wxString *arg2 = 0 ;
14433 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14434 int arg4 = (int) -1 ;
14435 bool result;
14436 void *argp1 = 0 ;
14437 int res1 = 0 ;
14438 bool temp2 = false ;
14439 long val3 ;
14440 int ecode3 = 0 ;
14441 int val4 ;
14442 int ecode4 = 0 ;
14443 PyObject * obj0 = 0 ;
14444 PyObject * obj1 = 0 ;
14445 PyObject * obj2 = 0 ;
14446 PyObject * obj3 = 0 ;
14447 char * kwnames[] = {
14448 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14449 };
14450
14451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14453 if (!SWIG_IsOK(res1)) {
14454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14455 }
14456 arg1 = reinterpret_cast< wxImage * >(argp1);
14457 {
14458 arg2 = wxString_in_helper(obj1);
14459 if (arg2 == NULL) SWIG_fail;
14460 temp2 = true;
14461 }
14462 if (obj2) {
14463 ecode3 = SWIG_AsVal_long(obj2, &val3);
14464 if (!SWIG_IsOK(ecode3)) {
14465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14466 }
14467 arg3 = static_cast< long >(val3);
14468 }
14469 if (obj3) {
14470 ecode4 = SWIG_AsVal_int(obj3, &val4);
14471 if (!SWIG_IsOK(ecode4)) {
14472 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14473 }
14474 arg4 = static_cast< int >(val4);
14475 }
14476 {
14477 PyThreadState* __tstate = wxPyBeginAllowThreads();
14478 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14479 wxPyEndAllowThreads(__tstate);
14480 if (PyErr_Occurred()) SWIG_fail;
14481 }
14482 {
14483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14484 }
14485 {
14486 if (temp2)
14487 delete arg2;
14488 }
14489 return resultobj;
14490 fail:
14491 {
14492 if (temp2)
14493 delete arg2;
14494 }
14495 return NULL;
14496 }
14497
14498
14499 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14500 PyObject *resultobj = 0;
14501 wxImage *arg1 = (wxImage *) 0 ;
14502 wxString *arg2 = 0 ;
14503 wxString *arg3 = 0 ;
14504 int arg4 = (int) -1 ;
14505 bool result;
14506 void *argp1 = 0 ;
14507 int res1 = 0 ;
14508 bool temp2 = false ;
14509 bool temp3 = false ;
14510 int val4 ;
14511 int ecode4 = 0 ;
14512 PyObject * obj0 = 0 ;
14513 PyObject * obj1 = 0 ;
14514 PyObject * obj2 = 0 ;
14515 PyObject * obj3 = 0 ;
14516 char * kwnames[] = {
14517 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14518 };
14519
14520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14522 if (!SWIG_IsOK(res1)) {
14523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14524 }
14525 arg1 = reinterpret_cast< wxImage * >(argp1);
14526 {
14527 arg2 = wxString_in_helper(obj1);
14528 if (arg2 == NULL) SWIG_fail;
14529 temp2 = true;
14530 }
14531 {
14532 arg3 = wxString_in_helper(obj2);
14533 if (arg3 == NULL) SWIG_fail;
14534 temp3 = true;
14535 }
14536 if (obj3) {
14537 ecode4 = SWIG_AsVal_int(obj3, &val4);
14538 if (!SWIG_IsOK(ecode4)) {
14539 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14540 }
14541 arg4 = static_cast< int >(val4);
14542 }
14543 {
14544 PyThreadState* __tstate = wxPyBeginAllowThreads();
14545 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14546 wxPyEndAllowThreads(__tstate);
14547 if (PyErr_Occurred()) SWIG_fail;
14548 }
14549 {
14550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14551 }
14552 {
14553 if (temp2)
14554 delete arg2;
14555 }
14556 {
14557 if (temp3)
14558 delete arg3;
14559 }
14560 return resultobj;
14561 fail:
14562 {
14563 if (temp2)
14564 delete arg2;
14565 }
14566 {
14567 if (temp3)
14568 delete arg3;
14569 }
14570 return NULL;
14571 }
14572
14573
14574 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14575 PyObject *resultobj = 0;
14576 wxImage *arg1 = (wxImage *) 0 ;
14577 wxString *arg2 = 0 ;
14578 int arg3 ;
14579 bool result;
14580 void *argp1 = 0 ;
14581 int res1 = 0 ;
14582 bool temp2 = false ;
14583 int val3 ;
14584 int ecode3 = 0 ;
14585 PyObject * obj0 = 0 ;
14586 PyObject * obj1 = 0 ;
14587 PyObject * obj2 = 0 ;
14588 char * kwnames[] = {
14589 (char *) "self",(char *) "name",(char *) "type", NULL
14590 };
14591
14592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14594 if (!SWIG_IsOK(res1)) {
14595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14596 }
14597 arg1 = reinterpret_cast< wxImage * >(argp1);
14598 {
14599 arg2 = wxString_in_helper(obj1);
14600 if (arg2 == NULL) SWIG_fail;
14601 temp2 = true;
14602 }
14603 ecode3 = SWIG_AsVal_int(obj2, &val3);
14604 if (!SWIG_IsOK(ecode3)) {
14605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14606 }
14607 arg3 = static_cast< int >(val3);
14608 {
14609 PyThreadState* __tstate = wxPyBeginAllowThreads();
14610 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14611 wxPyEndAllowThreads(__tstate);
14612 if (PyErr_Occurred()) SWIG_fail;
14613 }
14614 {
14615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14616 }
14617 {
14618 if (temp2)
14619 delete arg2;
14620 }
14621 return resultobj;
14622 fail:
14623 {
14624 if (temp2)
14625 delete arg2;
14626 }
14627 return NULL;
14628 }
14629
14630
14631 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14632 PyObject *resultobj = 0;
14633 wxImage *arg1 = (wxImage *) 0 ;
14634 wxString *arg2 = 0 ;
14635 wxString *arg3 = 0 ;
14636 bool result;
14637 void *argp1 = 0 ;
14638 int res1 = 0 ;
14639 bool temp2 = false ;
14640 bool temp3 = false ;
14641 PyObject * obj0 = 0 ;
14642 PyObject * obj1 = 0 ;
14643 PyObject * obj2 = 0 ;
14644 char * kwnames[] = {
14645 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14646 };
14647
14648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14650 if (!SWIG_IsOK(res1)) {
14651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14652 }
14653 arg1 = reinterpret_cast< wxImage * >(argp1);
14654 {
14655 arg2 = wxString_in_helper(obj1);
14656 if (arg2 == NULL) SWIG_fail;
14657 temp2 = true;
14658 }
14659 {
14660 arg3 = wxString_in_helper(obj2);
14661 if (arg3 == NULL) SWIG_fail;
14662 temp3 = true;
14663 }
14664 {
14665 PyThreadState* __tstate = wxPyBeginAllowThreads();
14666 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14667 wxPyEndAllowThreads(__tstate);
14668 if (PyErr_Occurred()) SWIG_fail;
14669 }
14670 {
14671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14672 }
14673 {
14674 if (temp2)
14675 delete arg2;
14676 }
14677 {
14678 if (temp3)
14679 delete arg3;
14680 }
14681 return resultobj;
14682 fail:
14683 {
14684 if (temp2)
14685 delete arg2;
14686 }
14687 {
14688 if (temp3)
14689 delete arg3;
14690 }
14691 return NULL;
14692 }
14693
14694
14695 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14696 PyObject *resultobj = 0;
14697 wxInputStream *arg1 = 0 ;
14698 bool result;
14699 wxPyInputStream *temp1 ;
14700 bool created1 ;
14701 PyObject * obj0 = 0 ;
14702 char * kwnames[] = {
14703 (char *) "stream", NULL
14704 };
14705
14706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14707 {
14708 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14709 arg1 = temp1->m_wxis;
14710 created1 = false;
14711 } else {
14712 PyErr_Clear(); // clear the failure of the wxPyConvert above
14713 arg1 = wxPyCBInputStream_create(obj0, false);
14714 if (arg1 == NULL) {
14715 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14716 SWIG_fail;
14717 }
14718 created1 = true;
14719 }
14720 }
14721 {
14722 PyThreadState* __tstate = wxPyBeginAllowThreads();
14723 result = (bool)wxImage::CanRead(*arg1);
14724 wxPyEndAllowThreads(__tstate);
14725 if (PyErr_Occurred()) SWIG_fail;
14726 }
14727 {
14728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14729 }
14730 {
14731 if (created1) delete arg1;
14732 }
14733 return resultobj;
14734 fail:
14735 {
14736 if (created1) delete arg1;
14737 }
14738 return NULL;
14739 }
14740
14741
14742 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14743 PyObject *resultobj = 0;
14744 wxImage *arg1 = (wxImage *) 0 ;
14745 wxInputStream *arg2 = 0 ;
14746 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14747 int arg4 = (int) -1 ;
14748 bool result;
14749 void *argp1 = 0 ;
14750 int res1 = 0 ;
14751 wxPyInputStream *temp2 ;
14752 bool created2 ;
14753 long val3 ;
14754 int ecode3 = 0 ;
14755 int val4 ;
14756 int ecode4 = 0 ;
14757 PyObject * obj0 = 0 ;
14758 PyObject * obj1 = 0 ;
14759 PyObject * obj2 = 0 ;
14760 PyObject * obj3 = 0 ;
14761 char * kwnames[] = {
14762 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14763 };
14764
14765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14767 if (!SWIG_IsOK(res1)) {
14768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14769 }
14770 arg1 = reinterpret_cast< wxImage * >(argp1);
14771 {
14772 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14773 arg2 = temp2->m_wxis;
14774 created2 = false;
14775 } else {
14776 PyErr_Clear(); // clear the failure of the wxPyConvert above
14777 arg2 = wxPyCBInputStream_create(obj1, false);
14778 if (arg2 == NULL) {
14779 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14780 SWIG_fail;
14781 }
14782 created2 = true;
14783 }
14784 }
14785 if (obj2) {
14786 ecode3 = SWIG_AsVal_long(obj2, &val3);
14787 if (!SWIG_IsOK(ecode3)) {
14788 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14789 }
14790 arg3 = static_cast< long >(val3);
14791 }
14792 if (obj3) {
14793 ecode4 = SWIG_AsVal_int(obj3, &val4);
14794 if (!SWIG_IsOK(ecode4)) {
14795 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14796 }
14797 arg4 = static_cast< int >(val4);
14798 }
14799 {
14800 PyThreadState* __tstate = wxPyBeginAllowThreads();
14801 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14802 wxPyEndAllowThreads(__tstate);
14803 if (PyErr_Occurred()) SWIG_fail;
14804 }
14805 {
14806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14807 }
14808 {
14809 if (created2) delete arg2;
14810 }
14811 return resultobj;
14812 fail:
14813 {
14814 if (created2) delete arg2;
14815 }
14816 return NULL;
14817 }
14818
14819
14820 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14821 PyObject *resultobj = 0;
14822 wxImage *arg1 = (wxImage *) 0 ;
14823 wxInputStream *arg2 = 0 ;
14824 wxString *arg3 = 0 ;
14825 int arg4 = (int) -1 ;
14826 bool result;
14827 void *argp1 = 0 ;
14828 int res1 = 0 ;
14829 wxPyInputStream *temp2 ;
14830 bool created2 ;
14831 bool temp3 = false ;
14832 int val4 ;
14833 int ecode4 = 0 ;
14834 PyObject * obj0 = 0 ;
14835 PyObject * obj1 = 0 ;
14836 PyObject * obj2 = 0 ;
14837 PyObject * obj3 = 0 ;
14838 char * kwnames[] = {
14839 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14840 };
14841
14842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14844 if (!SWIG_IsOK(res1)) {
14845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14846 }
14847 arg1 = reinterpret_cast< wxImage * >(argp1);
14848 {
14849 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14850 arg2 = temp2->m_wxis;
14851 created2 = false;
14852 } else {
14853 PyErr_Clear(); // clear the failure of the wxPyConvert above
14854 arg2 = wxPyCBInputStream_create(obj1, false);
14855 if (arg2 == NULL) {
14856 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14857 SWIG_fail;
14858 }
14859 created2 = true;
14860 }
14861 }
14862 {
14863 arg3 = wxString_in_helper(obj2);
14864 if (arg3 == NULL) SWIG_fail;
14865 temp3 = true;
14866 }
14867 if (obj3) {
14868 ecode4 = SWIG_AsVal_int(obj3, &val4);
14869 if (!SWIG_IsOK(ecode4)) {
14870 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14871 }
14872 arg4 = static_cast< int >(val4);
14873 }
14874 {
14875 PyThreadState* __tstate = wxPyBeginAllowThreads();
14876 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14877 wxPyEndAllowThreads(__tstate);
14878 if (PyErr_Occurred()) SWIG_fail;
14879 }
14880 {
14881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14882 }
14883 {
14884 if (created2) delete arg2;
14885 }
14886 {
14887 if (temp3)
14888 delete arg3;
14889 }
14890 return resultobj;
14891 fail:
14892 {
14893 if (created2) delete arg2;
14894 }
14895 {
14896 if (temp3)
14897 delete arg3;
14898 }
14899 return NULL;
14900 }
14901
14902
14903 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14904 PyObject *resultobj = 0;
14905 wxImage *arg1 = (wxImage *) 0 ;
14906 bool result;
14907 void *argp1 = 0 ;
14908 int res1 = 0 ;
14909 PyObject *swig_obj[1] ;
14910
14911 if (!args) SWIG_fail;
14912 swig_obj[0] = args;
14913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14914 if (!SWIG_IsOK(res1)) {
14915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14916 }
14917 arg1 = reinterpret_cast< wxImage * >(argp1);
14918 {
14919 PyThreadState* __tstate = wxPyBeginAllowThreads();
14920 result = (bool)(arg1)->Ok();
14921 wxPyEndAllowThreads(__tstate);
14922 if (PyErr_Occurred()) SWIG_fail;
14923 }
14924 {
14925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14926 }
14927 return resultobj;
14928 fail:
14929 return NULL;
14930 }
14931
14932
14933 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14934 PyObject *resultobj = 0;
14935 wxImage *arg1 = (wxImage *) 0 ;
14936 int result;
14937 void *argp1 = 0 ;
14938 int res1 = 0 ;
14939 PyObject *swig_obj[1] ;
14940
14941 if (!args) SWIG_fail;
14942 swig_obj[0] = args;
14943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14944 if (!SWIG_IsOK(res1)) {
14945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
14946 }
14947 arg1 = reinterpret_cast< wxImage * >(argp1);
14948 {
14949 PyThreadState* __tstate = wxPyBeginAllowThreads();
14950 result = (int)(arg1)->GetWidth();
14951 wxPyEndAllowThreads(__tstate);
14952 if (PyErr_Occurred()) SWIG_fail;
14953 }
14954 resultobj = SWIG_From_int(static_cast< int >(result));
14955 return resultobj;
14956 fail:
14957 return NULL;
14958 }
14959
14960
14961 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14962 PyObject *resultobj = 0;
14963 wxImage *arg1 = (wxImage *) 0 ;
14964 int result;
14965 void *argp1 = 0 ;
14966 int res1 = 0 ;
14967 PyObject *swig_obj[1] ;
14968
14969 if (!args) SWIG_fail;
14970 swig_obj[0] = args;
14971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14972 if (!SWIG_IsOK(res1)) {
14973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
14974 }
14975 arg1 = reinterpret_cast< wxImage * >(argp1);
14976 {
14977 PyThreadState* __tstate = wxPyBeginAllowThreads();
14978 result = (int)(arg1)->GetHeight();
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 resultobj = SWIG_From_int(static_cast< int >(result));
14983 return resultobj;
14984 fail:
14985 return NULL;
14986 }
14987
14988
14989 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14990 PyObject *resultobj = 0;
14991 wxImage *arg1 = (wxImage *) 0 ;
14992 wxSize result;
14993 void *argp1 = 0 ;
14994 int res1 = 0 ;
14995 PyObject *swig_obj[1] ;
14996
14997 if (!args) SWIG_fail;
14998 swig_obj[0] = args;
14999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15000 if (!SWIG_IsOK(res1)) {
15001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15002 }
15003 arg1 = reinterpret_cast< wxImage * >(argp1);
15004 {
15005 PyThreadState* __tstate = wxPyBeginAllowThreads();
15006 result = wxImage_GetSize(arg1);
15007 wxPyEndAllowThreads(__tstate);
15008 if (PyErr_Occurred()) SWIG_fail;
15009 }
15010 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15011 return resultobj;
15012 fail:
15013 return NULL;
15014 }
15015
15016
15017 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15018 PyObject *resultobj = 0;
15019 wxImage *arg1 = (wxImage *) 0 ;
15020 wxRect *arg2 = 0 ;
15021 SwigValueWrapper<wxImage > result;
15022 void *argp1 = 0 ;
15023 int res1 = 0 ;
15024 wxRect temp2 ;
15025 PyObject * obj0 = 0 ;
15026 PyObject * obj1 = 0 ;
15027 char * kwnames[] = {
15028 (char *) "self",(char *) "rect", NULL
15029 };
15030
15031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15033 if (!SWIG_IsOK(res1)) {
15034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15035 }
15036 arg1 = reinterpret_cast< wxImage * >(argp1);
15037 {
15038 arg2 = &temp2;
15039 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15040 }
15041 {
15042 PyThreadState* __tstate = wxPyBeginAllowThreads();
15043 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15044 wxPyEndAllowThreads(__tstate);
15045 if (PyErr_Occurred()) SWIG_fail;
15046 }
15047 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15048 return resultobj;
15049 fail:
15050 return NULL;
15051 }
15052
15053
15054 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15055 PyObject *resultobj = 0;
15056 wxImage *arg1 = (wxImage *) 0 ;
15057 wxSize *arg2 = 0 ;
15058 wxPoint *arg3 = 0 ;
15059 int arg4 = (int) -1 ;
15060 int arg5 = (int) -1 ;
15061 int arg6 = (int) -1 ;
15062 SwigValueWrapper<wxImage > result;
15063 void *argp1 = 0 ;
15064 int res1 = 0 ;
15065 wxSize temp2 ;
15066 wxPoint temp3 ;
15067 int val4 ;
15068 int ecode4 = 0 ;
15069 int val5 ;
15070 int ecode5 = 0 ;
15071 int val6 ;
15072 int ecode6 = 0 ;
15073 PyObject * obj0 = 0 ;
15074 PyObject * obj1 = 0 ;
15075 PyObject * obj2 = 0 ;
15076 PyObject * obj3 = 0 ;
15077 PyObject * obj4 = 0 ;
15078 PyObject * obj5 = 0 ;
15079 char * kwnames[] = {
15080 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15081 };
15082
15083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15087 }
15088 arg1 = reinterpret_cast< wxImage * >(argp1);
15089 {
15090 arg2 = &temp2;
15091 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15092 }
15093 {
15094 arg3 = &temp3;
15095 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15096 }
15097 if (obj3) {
15098 ecode4 = SWIG_AsVal_int(obj3, &val4);
15099 if (!SWIG_IsOK(ecode4)) {
15100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15101 }
15102 arg4 = static_cast< int >(val4);
15103 }
15104 if (obj4) {
15105 ecode5 = SWIG_AsVal_int(obj4, &val5);
15106 if (!SWIG_IsOK(ecode5)) {
15107 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15108 }
15109 arg5 = static_cast< int >(val5);
15110 }
15111 if (obj5) {
15112 ecode6 = SWIG_AsVal_int(obj5, &val6);
15113 if (!SWIG_IsOK(ecode6)) {
15114 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15115 }
15116 arg6 = static_cast< int >(val6);
15117 }
15118 {
15119 PyThreadState* __tstate = wxPyBeginAllowThreads();
15120 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15121 wxPyEndAllowThreads(__tstate);
15122 if (PyErr_Occurred()) SWIG_fail;
15123 }
15124 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15125 return resultobj;
15126 fail:
15127 return NULL;
15128 }
15129
15130
15131 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15132 PyObject *resultobj = 0;
15133 wxImage *arg1 = (wxImage *) 0 ;
15134 SwigValueWrapper<wxImage > result;
15135 void *argp1 = 0 ;
15136 int res1 = 0 ;
15137 PyObject *swig_obj[1] ;
15138
15139 if (!args) SWIG_fail;
15140 swig_obj[0] = args;
15141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15142 if (!SWIG_IsOK(res1)) {
15143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15144 }
15145 arg1 = reinterpret_cast< wxImage * >(argp1);
15146 {
15147 PyThreadState* __tstate = wxPyBeginAllowThreads();
15148 result = (arg1)->Copy();
15149 wxPyEndAllowThreads(__tstate);
15150 if (PyErr_Occurred()) SWIG_fail;
15151 }
15152 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15153 return resultobj;
15154 fail:
15155 return NULL;
15156 }
15157
15158
15159 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15160 PyObject *resultobj = 0;
15161 wxImage *arg1 = (wxImage *) 0 ;
15162 wxImage *arg2 = 0 ;
15163 int arg3 ;
15164 int arg4 ;
15165 void *argp1 = 0 ;
15166 int res1 = 0 ;
15167 void *argp2 = 0 ;
15168 int res2 = 0 ;
15169 int val3 ;
15170 int ecode3 = 0 ;
15171 int val4 ;
15172 int ecode4 = 0 ;
15173 PyObject * obj0 = 0 ;
15174 PyObject * obj1 = 0 ;
15175 PyObject * obj2 = 0 ;
15176 PyObject * obj3 = 0 ;
15177 char * kwnames[] = {
15178 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15179 };
15180
15181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15183 if (!SWIG_IsOK(res1)) {
15184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15185 }
15186 arg1 = reinterpret_cast< wxImage * >(argp1);
15187 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15188 if (!SWIG_IsOK(res2)) {
15189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15190 }
15191 if (!argp2) {
15192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15193 }
15194 arg2 = reinterpret_cast< wxImage * >(argp2);
15195 ecode3 = SWIG_AsVal_int(obj2, &val3);
15196 if (!SWIG_IsOK(ecode3)) {
15197 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15198 }
15199 arg3 = static_cast< int >(val3);
15200 ecode4 = SWIG_AsVal_int(obj3, &val4);
15201 if (!SWIG_IsOK(ecode4)) {
15202 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15203 }
15204 arg4 = static_cast< int >(val4);
15205 {
15206 PyThreadState* __tstate = wxPyBeginAllowThreads();
15207 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15208 wxPyEndAllowThreads(__tstate);
15209 if (PyErr_Occurred()) SWIG_fail;
15210 }
15211 resultobj = SWIG_Py_Void();
15212 return resultobj;
15213 fail:
15214 return NULL;
15215 }
15216
15217
15218 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15219 PyObject *resultobj = 0;
15220 wxImage *arg1 = (wxImage *) 0 ;
15221 PyObject *result = 0 ;
15222 void *argp1 = 0 ;
15223 int res1 = 0 ;
15224 PyObject *swig_obj[1] ;
15225
15226 if (!args) SWIG_fail;
15227 swig_obj[0] = args;
15228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15229 if (!SWIG_IsOK(res1)) {
15230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15231 }
15232 arg1 = reinterpret_cast< wxImage * >(argp1);
15233 {
15234 PyThreadState* __tstate = wxPyBeginAllowThreads();
15235 result = (PyObject *)wxImage_GetData(arg1);
15236 wxPyEndAllowThreads(__tstate);
15237 if (PyErr_Occurred()) SWIG_fail;
15238 }
15239 resultobj = result;
15240 return resultobj;
15241 fail:
15242 return NULL;
15243 }
15244
15245
15246 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15247 PyObject *resultobj = 0;
15248 wxImage *arg1 = (wxImage *) 0 ;
15249 buffer arg2 ;
15250 int arg3 ;
15251 void *argp1 = 0 ;
15252 int res1 = 0 ;
15253 PyObject * obj0 = 0 ;
15254 PyObject * obj1 = 0 ;
15255 char * kwnames[] = {
15256 (char *) "self",(char *) "data", NULL
15257 };
15258
15259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15261 if (!SWIG_IsOK(res1)) {
15262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15263 }
15264 arg1 = reinterpret_cast< wxImage * >(argp1);
15265 {
15266 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15267 }
15268 {
15269 PyThreadState* __tstate = wxPyBeginAllowThreads();
15270 wxImage_SetData(arg1,arg2,arg3);
15271 wxPyEndAllowThreads(__tstate);
15272 if (PyErr_Occurred()) SWIG_fail;
15273 }
15274 resultobj = SWIG_Py_Void();
15275 return resultobj;
15276 fail:
15277 return NULL;
15278 }
15279
15280
15281 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15282 PyObject *resultobj = 0;
15283 wxImage *arg1 = (wxImage *) 0 ;
15284 PyObject *result = 0 ;
15285 void *argp1 = 0 ;
15286 int res1 = 0 ;
15287 PyObject *swig_obj[1] ;
15288
15289 if (!args) SWIG_fail;
15290 swig_obj[0] = args;
15291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15292 if (!SWIG_IsOK(res1)) {
15293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15294 }
15295 arg1 = reinterpret_cast< wxImage * >(argp1);
15296 {
15297 PyThreadState* __tstate = wxPyBeginAllowThreads();
15298 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15299 wxPyEndAllowThreads(__tstate);
15300 if (PyErr_Occurred()) SWIG_fail;
15301 }
15302 resultobj = result;
15303 return resultobj;
15304 fail:
15305 return NULL;
15306 }
15307
15308
15309 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15310 PyObject *resultobj = 0;
15311 wxImage *arg1 = (wxImage *) 0 ;
15312 buffer arg2 ;
15313 int arg3 ;
15314 void *argp1 = 0 ;
15315 int res1 = 0 ;
15316 PyObject * obj0 = 0 ;
15317 PyObject * obj1 = 0 ;
15318 char * kwnames[] = {
15319 (char *) "self",(char *) "data", NULL
15320 };
15321
15322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15324 if (!SWIG_IsOK(res1)) {
15325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15326 }
15327 arg1 = reinterpret_cast< wxImage * >(argp1);
15328 {
15329 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15330 }
15331 {
15332 PyThreadState* __tstate = wxPyBeginAllowThreads();
15333 wxImage_SetDataBuffer(arg1,arg2,arg3);
15334 wxPyEndAllowThreads(__tstate);
15335 if (PyErr_Occurred()) SWIG_fail;
15336 }
15337 resultobj = SWIG_Py_Void();
15338 return resultobj;
15339 fail:
15340 return NULL;
15341 }
15342
15343
15344 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15345 PyObject *resultobj = 0;
15346 wxImage *arg1 = (wxImage *) 0 ;
15347 PyObject *result = 0 ;
15348 void *argp1 = 0 ;
15349 int res1 = 0 ;
15350 PyObject *swig_obj[1] ;
15351
15352 if (!args) SWIG_fail;
15353 swig_obj[0] = args;
15354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15355 if (!SWIG_IsOK(res1)) {
15356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15357 }
15358 arg1 = reinterpret_cast< wxImage * >(argp1);
15359 {
15360 PyThreadState* __tstate = wxPyBeginAllowThreads();
15361 result = (PyObject *)wxImage_GetAlphaData(arg1);
15362 wxPyEndAllowThreads(__tstate);
15363 if (PyErr_Occurred()) SWIG_fail;
15364 }
15365 resultobj = result;
15366 return resultobj;
15367 fail:
15368 return NULL;
15369 }
15370
15371
15372 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15373 PyObject *resultobj = 0;
15374 wxImage *arg1 = (wxImage *) 0 ;
15375 buffer arg2 ;
15376 int arg3 ;
15377 void *argp1 = 0 ;
15378 int res1 = 0 ;
15379 PyObject * obj0 = 0 ;
15380 PyObject * obj1 = 0 ;
15381 char * kwnames[] = {
15382 (char *) "self",(char *) "alpha", NULL
15383 };
15384
15385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15387 if (!SWIG_IsOK(res1)) {
15388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15389 }
15390 arg1 = reinterpret_cast< wxImage * >(argp1);
15391 {
15392 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15393 }
15394 {
15395 PyThreadState* __tstate = wxPyBeginAllowThreads();
15396 wxImage_SetAlphaData(arg1,arg2,arg3);
15397 wxPyEndAllowThreads(__tstate);
15398 if (PyErr_Occurred()) SWIG_fail;
15399 }
15400 resultobj = SWIG_Py_Void();
15401 return resultobj;
15402 fail:
15403 return NULL;
15404 }
15405
15406
15407 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15408 PyObject *resultobj = 0;
15409 wxImage *arg1 = (wxImage *) 0 ;
15410 PyObject *result = 0 ;
15411 void *argp1 = 0 ;
15412 int res1 = 0 ;
15413 PyObject *swig_obj[1] ;
15414
15415 if (!args) SWIG_fail;
15416 swig_obj[0] = args;
15417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15418 if (!SWIG_IsOK(res1)) {
15419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15420 }
15421 arg1 = reinterpret_cast< wxImage * >(argp1);
15422 {
15423 PyThreadState* __tstate = wxPyBeginAllowThreads();
15424 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15425 wxPyEndAllowThreads(__tstate);
15426 if (PyErr_Occurred()) SWIG_fail;
15427 }
15428 resultobj = result;
15429 return resultobj;
15430 fail:
15431 return NULL;
15432 }
15433
15434
15435 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15436 PyObject *resultobj = 0;
15437 wxImage *arg1 = (wxImage *) 0 ;
15438 buffer arg2 ;
15439 int arg3 ;
15440 void *argp1 = 0 ;
15441 int res1 = 0 ;
15442 PyObject * obj0 = 0 ;
15443 PyObject * obj1 = 0 ;
15444 char * kwnames[] = {
15445 (char *) "self",(char *) "alpha", NULL
15446 };
15447
15448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15450 if (!SWIG_IsOK(res1)) {
15451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15452 }
15453 arg1 = reinterpret_cast< wxImage * >(argp1);
15454 {
15455 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15456 }
15457 {
15458 PyThreadState* __tstate = wxPyBeginAllowThreads();
15459 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15460 wxPyEndAllowThreads(__tstate);
15461 if (PyErr_Occurred()) SWIG_fail;
15462 }
15463 resultobj = SWIG_Py_Void();
15464 return resultobj;
15465 fail:
15466 return NULL;
15467 }
15468
15469
15470 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15471 PyObject *resultobj = 0;
15472 wxImage *arg1 = (wxImage *) 0 ;
15473 byte arg2 ;
15474 byte arg3 ;
15475 byte arg4 ;
15476 void *argp1 = 0 ;
15477 int res1 = 0 ;
15478 unsigned char val2 ;
15479 int ecode2 = 0 ;
15480 unsigned char val3 ;
15481 int ecode3 = 0 ;
15482 unsigned char val4 ;
15483 int ecode4 = 0 ;
15484 PyObject * obj0 = 0 ;
15485 PyObject * obj1 = 0 ;
15486 PyObject * obj2 = 0 ;
15487 PyObject * obj3 = 0 ;
15488 char * kwnames[] = {
15489 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15490 };
15491
15492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15494 if (!SWIG_IsOK(res1)) {
15495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15496 }
15497 arg1 = reinterpret_cast< wxImage * >(argp1);
15498 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15499 if (!SWIG_IsOK(ecode2)) {
15500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15501 }
15502 arg2 = static_cast< byte >(val2);
15503 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15504 if (!SWIG_IsOK(ecode3)) {
15505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15506 }
15507 arg3 = static_cast< byte >(val3);
15508 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15509 if (!SWIG_IsOK(ecode4)) {
15510 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15511 }
15512 arg4 = static_cast< byte >(val4);
15513 {
15514 PyThreadState* __tstate = wxPyBeginAllowThreads();
15515 (arg1)->SetMaskColour(arg2,arg3,arg4);
15516 wxPyEndAllowThreads(__tstate);
15517 if (PyErr_Occurred()) SWIG_fail;
15518 }
15519 resultobj = SWIG_Py_Void();
15520 return resultobj;
15521 fail:
15522 return NULL;
15523 }
15524
15525
15526 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15527 PyObject *resultobj = 0;
15528 wxImage *arg1 = (wxImage *) 0 ;
15529 byte *arg2 = (byte *) 0 ;
15530 byte *arg3 = (byte *) 0 ;
15531 byte *arg4 = (byte *) 0 ;
15532 void *argp1 = 0 ;
15533 int res1 = 0 ;
15534 byte temp2 ;
15535 int res2 = SWIG_TMPOBJ ;
15536 byte temp3 ;
15537 int res3 = SWIG_TMPOBJ ;
15538 byte temp4 ;
15539 int res4 = SWIG_TMPOBJ ;
15540 PyObject *swig_obj[1] ;
15541
15542 arg2 = &temp2;
15543 arg3 = &temp3;
15544 arg4 = &temp4;
15545 if (!args) SWIG_fail;
15546 swig_obj[0] = args;
15547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15548 if (!SWIG_IsOK(res1)) {
15549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15550 }
15551 arg1 = reinterpret_cast< wxImage * >(argp1);
15552 {
15553 PyThreadState* __tstate = wxPyBeginAllowThreads();
15554 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15555 wxPyEndAllowThreads(__tstate);
15556 if (PyErr_Occurred()) SWIG_fail;
15557 }
15558 resultobj = SWIG_Py_Void();
15559 if (SWIG_IsTmpObj(res2)) {
15560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15561 } else {
15562 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15563 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15564 }
15565 if (SWIG_IsTmpObj(res3)) {
15566 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15567 } else {
15568 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15569 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15570 }
15571 if (SWIG_IsTmpObj(res4)) {
15572 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15573 } else {
15574 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15575 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15576 }
15577 return resultobj;
15578 fail:
15579 return NULL;
15580 }
15581
15582
15583 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15584 PyObject *resultobj = 0;
15585 wxImage *arg1 = (wxImage *) 0 ;
15586 byte result;
15587 void *argp1 = 0 ;
15588 int res1 = 0 ;
15589 PyObject *swig_obj[1] ;
15590
15591 if (!args) SWIG_fail;
15592 swig_obj[0] = args;
15593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15594 if (!SWIG_IsOK(res1)) {
15595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15596 }
15597 arg1 = reinterpret_cast< wxImage * >(argp1);
15598 {
15599 PyThreadState* __tstate = wxPyBeginAllowThreads();
15600 result = (byte)(arg1)->GetMaskRed();
15601 wxPyEndAllowThreads(__tstate);
15602 if (PyErr_Occurred()) SWIG_fail;
15603 }
15604 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15605 return resultobj;
15606 fail:
15607 return NULL;
15608 }
15609
15610
15611 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15612 PyObject *resultobj = 0;
15613 wxImage *arg1 = (wxImage *) 0 ;
15614 byte result;
15615 void *argp1 = 0 ;
15616 int res1 = 0 ;
15617 PyObject *swig_obj[1] ;
15618
15619 if (!args) SWIG_fail;
15620 swig_obj[0] = args;
15621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15622 if (!SWIG_IsOK(res1)) {
15623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15624 }
15625 arg1 = reinterpret_cast< wxImage * >(argp1);
15626 {
15627 PyThreadState* __tstate = wxPyBeginAllowThreads();
15628 result = (byte)(arg1)->GetMaskGreen();
15629 wxPyEndAllowThreads(__tstate);
15630 if (PyErr_Occurred()) SWIG_fail;
15631 }
15632 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15633 return resultobj;
15634 fail:
15635 return NULL;
15636 }
15637
15638
15639 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15640 PyObject *resultobj = 0;
15641 wxImage *arg1 = (wxImage *) 0 ;
15642 byte result;
15643 void *argp1 = 0 ;
15644 int res1 = 0 ;
15645 PyObject *swig_obj[1] ;
15646
15647 if (!args) SWIG_fail;
15648 swig_obj[0] = args;
15649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15650 if (!SWIG_IsOK(res1)) {
15651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15652 }
15653 arg1 = reinterpret_cast< wxImage * >(argp1);
15654 {
15655 PyThreadState* __tstate = wxPyBeginAllowThreads();
15656 result = (byte)(arg1)->GetMaskBlue();
15657 wxPyEndAllowThreads(__tstate);
15658 if (PyErr_Occurred()) SWIG_fail;
15659 }
15660 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15661 return resultobj;
15662 fail:
15663 return NULL;
15664 }
15665
15666
15667 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15668 PyObject *resultobj = 0;
15669 wxImage *arg1 = (wxImage *) 0 ;
15670 bool arg2 = (bool) true ;
15671 void *argp1 = 0 ;
15672 int res1 = 0 ;
15673 bool val2 ;
15674 int ecode2 = 0 ;
15675 PyObject * obj0 = 0 ;
15676 PyObject * obj1 = 0 ;
15677 char * kwnames[] = {
15678 (char *) "self",(char *) "mask", NULL
15679 };
15680
15681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15683 if (!SWIG_IsOK(res1)) {
15684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15685 }
15686 arg1 = reinterpret_cast< wxImage * >(argp1);
15687 if (obj1) {
15688 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15689 if (!SWIG_IsOK(ecode2)) {
15690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15691 }
15692 arg2 = static_cast< bool >(val2);
15693 }
15694 {
15695 PyThreadState* __tstate = wxPyBeginAllowThreads();
15696 (arg1)->SetMask(arg2);
15697 wxPyEndAllowThreads(__tstate);
15698 if (PyErr_Occurred()) SWIG_fail;
15699 }
15700 resultobj = SWIG_Py_Void();
15701 return resultobj;
15702 fail:
15703 return NULL;
15704 }
15705
15706
15707 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15708 PyObject *resultobj = 0;
15709 wxImage *arg1 = (wxImage *) 0 ;
15710 bool result;
15711 void *argp1 = 0 ;
15712 int res1 = 0 ;
15713 PyObject *swig_obj[1] ;
15714
15715 if (!args) SWIG_fail;
15716 swig_obj[0] = args;
15717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15718 if (!SWIG_IsOK(res1)) {
15719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15720 }
15721 arg1 = reinterpret_cast< wxImage * >(argp1);
15722 {
15723 PyThreadState* __tstate = wxPyBeginAllowThreads();
15724 result = (bool)(arg1)->HasMask();
15725 wxPyEndAllowThreads(__tstate);
15726 if (PyErr_Occurred()) SWIG_fail;
15727 }
15728 {
15729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15730 }
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15738 PyObject *resultobj = 0;
15739 wxImage *arg1 = (wxImage *) 0 ;
15740 double arg2 ;
15741 wxPoint *arg3 = 0 ;
15742 bool arg4 = (bool) true ;
15743 wxPoint *arg5 = (wxPoint *) NULL ;
15744 SwigValueWrapper<wxImage > result;
15745 void *argp1 = 0 ;
15746 int res1 = 0 ;
15747 double val2 ;
15748 int ecode2 = 0 ;
15749 wxPoint temp3 ;
15750 bool val4 ;
15751 int ecode4 = 0 ;
15752 void *argp5 = 0 ;
15753 int res5 = 0 ;
15754 PyObject * obj0 = 0 ;
15755 PyObject * obj1 = 0 ;
15756 PyObject * obj2 = 0 ;
15757 PyObject * obj3 = 0 ;
15758 PyObject * obj4 = 0 ;
15759 char * kwnames[] = {
15760 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15761 };
15762
15763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15765 if (!SWIG_IsOK(res1)) {
15766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15767 }
15768 arg1 = reinterpret_cast< wxImage * >(argp1);
15769 ecode2 = SWIG_AsVal_double(obj1, &val2);
15770 if (!SWIG_IsOK(ecode2)) {
15771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15772 }
15773 arg2 = static_cast< double >(val2);
15774 {
15775 arg3 = &temp3;
15776 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15777 }
15778 if (obj3) {
15779 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15780 if (!SWIG_IsOK(ecode4)) {
15781 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15782 }
15783 arg4 = static_cast< bool >(val4);
15784 }
15785 if (obj4) {
15786 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15787 if (!SWIG_IsOK(res5)) {
15788 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15789 }
15790 arg5 = reinterpret_cast< wxPoint * >(argp5);
15791 }
15792 {
15793 PyThreadState* __tstate = wxPyBeginAllowThreads();
15794 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15795 wxPyEndAllowThreads(__tstate);
15796 if (PyErr_Occurred()) SWIG_fail;
15797 }
15798 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15799 return resultobj;
15800 fail:
15801 return NULL;
15802 }
15803
15804
15805 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15806 PyObject *resultobj = 0;
15807 wxImage *arg1 = (wxImage *) 0 ;
15808 bool arg2 = (bool) true ;
15809 SwigValueWrapper<wxImage > result;
15810 void *argp1 = 0 ;
15811 int res1 = 0 ;
15812 bool val2 ;
15813 int ecode2 = 0 ;
15814 PyObject * obj0 = 0 ;
15815 PyObject * obj1 = 0 ;
15816 char * kwnames[] = {
15817 (char *) "self",(char *) "clockwise", NULL
15818 };
15819
15820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15822 if (!SWIG_IsOK(res1)) {
15823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15824 }
15825 arg1 = reinterpret_cast< wxImage * >(argp1);
15826 if (obj1) {
15827 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15828 if (!SWIG_IsOK(ecode2)) {
15829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15830 }
15831 arg2 = static_cast< bool >(val2);
15832 }
15833 {
15834 PyThreadState* __tstate = wxPyBeginAllowThreads();
15835 result = (arg1)->Rotate90(arg2);
15836 wxPyEndAllowThreads(__tstate);
15837 if (PyErr_Occurred()) SWIG_fail;
15838 }
15839 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15840 return resultobj;
15841 fail:
15842 return NULL;
15843 }
15844
15845
15846 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15847 PyObject *resultobj = 0;
15848 wxImage *arg1 = (wxImage *) 0 ;
15849 bool arg2 = (bool) true ;
15850 SwigValueWrapper<wxImage > result;
15851 void *argp1 = 0 ;
15852 int res1 = 0 ;
15853 bool val2 ;
15854 int ecode2 = 0 ;
15855 PyObject * obj0 = 0 ;
15856 PyObject * obj1 = 0 ;
15857 char * kwnames[] = {
15858 (char *) "self",(char *) "horizontally", NULL
15859 };
15860
15861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15863 if (!SWIG_IsOK(res1)) {
15864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15865 }
15866 arg1 = reinterpret_cast< wxImage * >(argp1);
15867 if (obj1) {
15868 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15869 if (!SWIG_IsOK(ecode2)) {
15870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15871 }
15872 arg2 = static_cast< bool >(val2);
15873 }
15874 {
15875 PyThreadState* __tstate = wxPyBeginAllowThreads();
15876 result = (arg1)->Mirror(arg2);
15877 wxPyEndAllowThreads(__tstate);
15878 if (PyErr_Occurred()) SWIG_fail;
15879 }
15880 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15881 return resultobj;
15882 fail:
15883 return NULL;
15884 }
15885
15886
15887 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15888 PyObject *resultobj = 0;
15889 wxImage *arg1 = (wxImage *) 0 ;
15890 byte arg2 ;
15891 byte arg3 ;
15892 byte arg4 ;
15893 byte arg5 ;
15894 byte arg6 ;
15895 byte arg7 ;
15896 void *argp1 = 0 ;
15897 int res1 = 0 ;
15898 unsigned char val2 ;
15899 int ecode2 = 0 ;
15900 unsigned char val3 ;
15901 int ecode3 = 0 ;
15902 unsigned char val4 ;
15903 int ecode4 = 0 ;
15904 unsigned char val5 ;
15905 int ecode5 = 0 ;
15906 unsigned char val6 ;
15907 int ecode6 = 0 ;
15908 unsigned char val7 ;
15909 int ecode7 = 0 ;
15910 PyObject * obj0 = 0 ;
15911 PyObject * obj1 = 0 ;
15912 PyObject * obj2 = 0 ;
15913 PyObject * obj3 = 0 ;
15914 PyObject * obj4 = 0 ;
15915 PyObject * obj5 = 0 ;
15916 PyObject * obj6 = 0 ;
15917 char * kwnames[] = {
15918 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15919 };
15920
15921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15923 if (!SWIG_IsOK(res1)) {
15924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15925 }
15926 arg1 = reinterpret_cast< wxImage * >(argp1);
15927 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15928 if (!SWIG_IsOK(ecode2)) {
15929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15930 }
15931 arg2 = static_cast< byte >(val2);
15932 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15933 if (!SWIG_IsOK(ecode3)) {
15934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15935 }
15936 arg3 = static_cast< byte >(val3);
15937 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15938 if (!SWIG_IsOK(ecode4)) {
15939 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
15940 }
15941 arg4 = static_cast< byte >(val4);
15942 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15943 if (!SWIG_IsOK(ecode5)) {
15944 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
15945 }
15946 arg5 = static_cast< byte >(val5);
15947 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
15948 if (!SWIG_IsOK(ecode6)) {
15949 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
15950 }
15951 arg6 = static_cast< byte >(val6);
15952 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
15953 if (!SWIG_IsOK(ecode7)) {
15954 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
15955 }
15956 arg7 = static_cast< byte >(val7);
15957 {
15958 PyThreadState* __tstate = wxPyBeginAllowThreads();
15959 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
15960 wxPyEndAllowThreads(__tstate);
15961 if (PyErr_Occurred()) SWIG_fail;
15962 }
15963 resultobj = SWIG_Py_Void();
15964 return resultobj;
15965 fail:
15966 return NULL;
15967 }
15968
15969
15970 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15971 PyObject *resultobj = 0;
15972 wxImage *arg1 = (wxImage *) 0 ;
15973 double arg2 = (double) 0.299 ;
15974 double arg3 = (double) 0.587 ;
15975 double arg4 = (double) 0.114 ;
15976 SwigValueWrapper<wxImage > result;
15977 void *argp1 = 0 ;
15978 int res1 = 0 ;
15979 double val2 ;
15980 int ecode2 = 0 ;
15981 double val3 ;
15982 int ecode3 = 0 ;
15983 double val4 ;
15984 int ecode4 = 0 ;
15985 PyObject * obj0 = 0 ;
15986 PyObject * obj1 = 0 ;
15987 PyObject * obj2 = 0 ;
15988 PyObject * obj3 = 0 ;
15989 char * kwnames[] = {
15990 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
15991 };
15992
15993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15995 if (!SWIG_IsOK(res1)) {
15996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
15997 }
15998 arg1 = reinterpret_cast< wxImage * >(argp1);
15999 if (obj1) {
16000 ecode2 = SWIG_AsVal_double(obj1, &val2);
16001 if (!SWIG_IsOK(ecode2)) {
16002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16003 }
16004 arg2 = static_cast< double >(val2);
16005 }
16006 if (obj2) {
16007 ecode3 = SWIG_AsVal_double(obj2, &val3);
16008 if (!SWIG_IsOK(ecode3)) {
16009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16010 }
16011 arg3 = static_cast< double >(val3);
16012 }
16013 if (obj3) {
16014 ecode4 = SWIG_AsVal_double(obj3, &val4);
16015 if (!SWIG_IsOK(ecode4)) {
16016 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16017 }
16018 arg4 = static_cast< double >(val4);
16019 }
16020 {
16021 PyThreadState* __tstate = wxPyBeginAllowThreads();
16022 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16023 wxPyEndAllowThreads(__tstate);
16024 if (PyErr_Occurred()) SWIG_fail;
16025 }
16026 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16027 return resultobj;
16028 fail:
16029 return NULL;
16030 }
16031
16032
16033 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16034 PyObject *resultobj = 0;
16035 wxImage *arg1 = (wxImage *) 0 ;
16036 byte arg2 ;
16037 byte arg3 ;
16038 byte arg4 ;
16039 SwigValueWrapper<wxImage > result;
16040 void *argp1 = 0 ;
16041 int res1 = 0 ;
16042 unsigned char val2 ;
16043 int ecode2 = 0 ;
16044 unsigned char val3 ;
16045 int ecode3 = 0 ;
16046 unsigned char val4 ;
16047 int ecode4 = 0 ;
16048 PyObject * obj0 = 0 ;
16049 PyObject * obj1 = 0 ;
16050 PyObject * obj2 = 0 ;
16051 PyObject * obj3 = 0 ;
16052 char * kwnames[] = {
16053 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16054 };
16055
16056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16058 if (!SWIG_IsOK(res1)) {
16059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16060 }
16061 arg1 = reinterpret_cast< wxImage * >(argp1);
16062 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16063 if (!SWIG_IsOK(ecode2)) {
16064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16065 }
16066 arg2 = static_cast< byte >(val2);
16067 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16068 if (!SWIG_IsOK(ecode3)) {
16069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16070 }
16071 arg3 = static_cast< byte >(val3);
16072 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16073 if (!SWIG_IsOK(ecode4)) {
16074 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16075 }
16076 arg4 = static_cast< byte >(val4);
16077 {
16078 PyThreadState* __tstate = wxPyBeginAllowThreads();
16079 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16080 wxPyEndAllowThreads(__tstate);
16081 if (PyErr_Occurred()) SWIG_fail;
16082 }
16083 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16084 return resultobj;
16085 fail:
16086 return NULL;
16087 }
16088
16089
16090 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16091 PyObject *resultobj = 0;
16092 wxImage *arg1 = (wxImage *) 0 ;
16093 wxString *arg2 = 0 ;
16094 wxString *arg3 = 0 ;
16095 void *argp1 = 0 ;
16096 int res1 = 0 ;
16097 bool temp2 = false ;
16098 bool temp3 = false ;
16099 PyObject * obj0 = 0 ;
16100 PyObject * obj1 = 0 ;
16101 PyObject * obj2 = 0 ;
16102 char * kwnames[] = {
16103 (char *) "self",(char *) "name",(char *) "value", NULL
16104 };
16105
16106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16108 if (!SWIG_IsOK(res1)) {
16109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16110 }
16111 arg1 = reinterpret_cast< wxImage * >(argp1);
16112 {
16113 arg2 = wxString_in_helper(obj1);
16114 if (arg2 == NULL) SWIG_fail;
16115 temp2 = true;
16116 }
16117 {
16118 arg3 = wxString_in_helper(obj2);
16119 if (arg3 == NULL) SWIG_fail;
16120 temp3 = true;
16121 }
16122 {
16123 PyThreadState* __tstate = wxPyBeginAllowThreads();
16124 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16125 wxPyEndAllowThreads(__tstate);
16126 if (PyErr_Occurred()) SWIG_fail;
16127 }
16128 resultobj = SWIG_Py_Void();
16129 {
16130 if (temp2)
16131 delete arg2;
16132 }
16133 {
16134 if (temp3)
16135 delete arg3;
16136 }
16137 return resultobj;
16138 fail:
16139 {
16140 if (temp2)
16141 delete arg2;
16142 }
16143 {
16144 if (temp3)
16145 delete arg3;
16146 }
16147 return NULL;
16148 }
16149
16150
16151 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16152 PyObject *resultobj = 0;
16153 wxImage *arg1 = (wxImage *) 0 ;
16154 wxString *arg2 = 0 ;
16155 int arg3 ;
16156 void *argp1 = 0 ;
16157 int res1 = 0 ;
16158 bool temp2 = false ;
16159 int val3 ;
16160 int ecode3 = 0 ;
16161 PyObject * obj0 = 0 ;
16162 PyObject * obj1 = 0 ;
16163 PyObject * obj2 = 0 ;
16164 char * kwnames[] = {
16165 (char *) "self",(char *) "name",(char *) "value", NULL
16166 };
16167
16168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16170 if (!SWIG_IsOK(res1)) {
16171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16172 }
16173 arg1 = reinterpret_cast< wxImage * >(argp1);
16174 {
16175 arg2 = wxString_in_helper(obj1);
16176 if (arg2 == NULL) SWIG_fail;
16177 temp2 = true;
16178 }
16179 ecode3 = SWIG_AsVal_int(obj2, &val3);
16180 if (!SWIG_IsOK(ecode3)) {
16181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16182 }
16183 arg3 = static_cast< int >(val3);
16184 {
16185 PyThreadState* __tstate = wxPyBeginAllowThreads();
16186 (arg1)->SetOption((wxString const &)*arg2,arg3);
16187 wxPyEndAllowThreads(__tstate);
16188 if (PyErr_Occurred()) SWIG_fail;
16189 }
16190 resultobj = SWIG_Py_Void();
16191 {
16192 if (temp2)
16193 delete arg2;
16194 }
16195 return resultobj;
16196 fail:
16197 {
16198 if (temp2)
16199 delete arg2;
16200 }
16201 return NULL;
16202 }
16203
16204
16205 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16206 PyObject *resultobj = 0;
16207 wxImage *arg1 = (wxImage *) 0 ;
16208 wxString *arg2 = 0 ;
16209 wxString result;
16210 void *argp1 = 0 ;
16211 int res1 = 0 ;
16212 bool temp2 = false ;
16213 PyObject * obj0 = 0 ;
16214 PyObject * obj1 = 0 ;
16215 char * kwnames[] = {
16216 (char *) "self",(char *) "name", NULL
16217 };
16218
16219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16221 if (!SWIG_IsOK(res1)) {
16222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16223 }
16224 arg1 = reinterpret_cast< wxImage * >(argp1);
16225 {
16226 arg2 = wxString_in_helper(obj1);
16227 if (arg2 == NULL) SWIG_fail;
16228 temp2 = true;
16229 }
16230 {
16231 PyThreadState* __tstate = wxPyBeginAllowThreads();
16232 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16233 wxPyEndAllowThreads(__tstate);
16234 if (PyErr_Occurred()) SWIG_fail;
16235 }
16236 {
16237 #if wxUSE_UNICODE
16238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16239 #else
16240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16241 #endif
16242 }
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_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16258 PyObject *resultobj = 0;
16259 wxImage *arg1 = (wxImage *) 0 ;
16260 wxString *arg2 = 0 ;
16261 int 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_GetOptionInt",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_GetOptionInt" "', 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 = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16285 wxPyEndAllowThreads(__tstate);
16286 if (PyErr_Occurred()) SWIG_fail;
16287 }
16288 resultobj = SWIG_From_int(static_cast< int >(result));
16289 {
16290 if (temp2)
16291 delete arg2;
16292 }
16293 return resultobj;
16294 fail:
16295 {
16296 if (temp2)
16297 delete arg2;
16298 }
16299 return NULL;
16300 }
16301
16302
16303 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16304 PyObject *resultobj = 0;
16305 wxImage *arg1 = (wxImage *) 0 ;
16306 wxString *arg2 = 0 ;
16307 bool result;
16308 void *argp1 = 0 ;
16309 int res1 = 0 ;
16310 bool temp2 = false ;
16311 PyObject * obj0 = 0 ;
16312 PyObject * obj1 = 0 ;
16313 char * kwnames[] = {
16314 (char *) "self",(char *) "name", NULL
16315 };
16316
16317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16319 if (!SWIG_IsOK(res1)) {
16320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16321 }
16322 arg1 = reinterpret_cast< wxImage * >(argp1);
16323 {
16324 arg2 = wxString_in_helper(obj1);
16325 if (arg2 == NULL) SWIG_fail;
16326 temp2 = true;
16327 }
16328 {
16329 PyThreadState* __tstate = wxPyBeginAllowThreads();
16330 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16331 wxPyEndAllowThreads(__tstate);
16332 if (PyErr_Occurred()) SWIG_fail;
16333 }
16334 {
16335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16336 }
16337 {
16338 if (temp2)
16339 delete arg2;
16340 }
16341 return resultobj;
16342 fail:
16343 {
16344 if (temp2)
16345 delete arg2;
16346 }
16347 return NULL;
16348 }
16349
16350
16351 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16352 PyObject *resultobj = 0;
16353 wxImage *arg1 = (wxImage *) 0 ;
16354 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16355 unsigned long result;
16356 void *argp1 = 0 ;
16357 int res1 = 0 ;
16358 unsigned long val2 ;
16359 int ecode2 = 0 ;
16360 PyObject * obj0 = 0 ;
16361 PyObject * obj1 = 0 ;
16362 char * kwnames[] = {
16363 (char *) "self",(char *) "stopafter", NULL
16364 };
16365
16366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16368 if (!SWIG_IsOK(res1)) {
16369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16370 }
16371 arg1 = reinterpret_cast< wxImage * >(argp1);
16372 if (obj1) {
16373 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16374 if (!SWIG_IsOK(ecode2)) {
16375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16376 }
16377 arg2 = static_cast< unsigned long >(val2);
16378 }
16379 {
16380 PyThreadState* __tstate = wxPyBeginAllowThreads();
16381 result = (unsigned long)(arg1)->CountColours(arg2);
16382 wxPyEndAllowThreads(__tstate);
16383 if (PyErr_Occurred()) SWIG_fail;
16384 }
16385 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16386 return resultobj;
16387 fail:
16388 return NULL;
16389 }
16390
16391
16392 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16393 PyObject *resultobj = 0;
16394 wxImage *arg1 = (wxImage *) 0 ;
16395 wxImageHistogram *arg2 = 0 ;
16396 unsigned long result;
16397 void *argp1 = 0 ;
16398 int res1 = 0 ;
16399 void *argp2 = 0 ;
16400 int res2 = 0 ;
16401 PyObject * obj0 = 0 ;
16402 PyObject * obj1 = 0 ;
16403 char * kwnames[] = {
16404 (char *) "self",(char *) "h", NULL
16405 };
16406
16407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16409 if (!SWIG_IsOK(res1)) {
16410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16411 }
16412 arg1 = reinterpret_cast< wxImage * >(argp1);
16413 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16414 if (!SWIG_IsOK(res2)) {
16415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16416 }
16417 if (!argp2) {
16418 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16419 }
16420 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16421 {
16422 PyThreadState* __tstate = wxPyBeginAllowThreads();
16423 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16424 wxPyEndAllowThreads(__tstate);
16425 if (PyErr_Occurred()) SWIG_fail;
16426 }
16427 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16428 return resultobj;
16429 fail:
16430 return NULL;
16431 }
16432
16433
16434 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16435 PyObject *resultobj = 0;
16436 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16437 void *argp1 = 0 ;
16438 int res1 = 0 ;
16439 PyObject * obj0 = 0 ;
16440 char * kwnames[] = {
16441 (char *) "handler", NULL
16442 };
16443
16444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16446 if (!SWIG_IsOK(res1)) {
16447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16448 }
16449 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16450 {
16451 PyThreadState* __tstate = wxPyBeginAllowThreads();
16452 wxImage::AddHandler(arg1);
16453 wxPyEndAllowThreads(__tstate);
16454 if (PyErr_Occurred()) SWIG_fail;
16455 }
16456 resultobj = SWIG_Py_Void();
16457 return resultobj;
16458 fail:
16459 return NULL;
16460 }
16461
16462
16463 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16464 PyObject *resultobj = 0;
16465 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16466 void *argp1 = 0 ;
16467 int res1 = 0 ;
16468 PyObject * obj0 = 0 ;
16469 char * kwnames[] = {
16470 (char *) "handler", NULL
16471 };
16472
16473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16475 if (!SWIG_IsOK(res1)) {
16476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16477 }
16478 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16479 {
16480 PyThreadState* __tstate = wxPyBeginAllowThreads();
16481 wxImage::InsertHandler(arg1);
16482 wxPyEndAllowThreads(__tstate);
16483 if (PyErr_Occurred()) SWIG_fail;
16484 }
16485 resultobj = SWIG_Py_Void();
16486 return resultobj;
16487 fail:
16488 return NULL;
16489 }
16490
16491
16492 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16493 PyObject *resultobj = 0;
16494 wxString *arg1 = 0 ;
16495 bool result;
16496 bool temp1 = false ;
16497 PyObject * obj0 = 0 ;
16498 char * kwnames[] = {
16499 (char *) "name", NULL
16500 };
16501
16502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16503 {
16504 arg1 = wxString_in_helper(obj0);
16505 if (arg1 == NULL) SWIG_fail;
16506 temp1 = true;
16507 }
16508 {
16509 PyThreadState* __tstate = wxPyBeginAllowThreads();
16510 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16511 wxPyEndAllowThreads(__tstate);
16512 if (PyErr_Occurred()) SWIG_fail;
16513 }
16514 {
16515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16516 }
16517 {
16518 if (temp1)
16519 delete arg1;
16520 }
16521 return resultobj;
16522 fail:
16523 {
16524 if (temp1)
16525 delete arg1;
16526 }
16527 return NULL;
16528 }
16529
16530
16531 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16532 PyObject *resultobj = 0;
16533 PyObject *result = 0 ;
16534
16535 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16536 {
16537 PyThreadState* __tstate = wxPyBeginAllowThreads();
16538 result = (PyObject *)wxImage_GetHandlers();
16539 wxPyEndAllowThreads(__tstate);
16540 if (PyErr_Occurred()) SWIG_fail;
16541 }
16542 resultobj = result;
16543 return resultobj;
16544 fail:
16545 return NULL;
16546 }
16547
16548
16549 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16550 PyObject *resultobj = 0;
16551 wxString result;
16552
16553 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16554 {
16555 PyThreadState* __tstate = wxPyBeginAllowThreads();
16556 result = wxImage::GetImageExtWildcard();
16557 wxPyEndAllowThreads(__tstate);
16558 if (PyErr_Occurred()) SWIG_fail;
16559 }
16560 {
16561 #if wxUSE_UNICODE
16562 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16563 #else
16564 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16565 #endif
16566 }
16567 return resultobj;
16568 fail:
16569 return NULL;
16570 }
16571
16572
16573 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16574 PyObject *resultobj = 0;
16575 wxImage *arg1 = (wxImage *) 0 ;
16576 int arg2 = (int) -1 ;
16577 wxBitmap result;
16578 void *argp1 = 0 ;
16579 int res1 = 0 ;
16580 int val2 ;
16581 int ecode2 = 0 ;
16582 PyObject * obj0 = 0 ;
16583 PyObject * obj1 = 0 ;
16584 char * kwnames[] = {
16585 (char *) "self",(char *) "depth", NULL
16586 };
16587
16588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16590 if (!SWIG_IsOK(res1)) {
16591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16592 }
16593 arg1 = reinterpret_cast< wxImage * >(argp1);
16594 if (obj1) {
16595 ecode2 = SWIG_AsVal_int(obj1, &val2);
16596 if (!SWIG_IsOK(ecode2)) {
16597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16598 }
16599 arg2 = static_cast< int >(val2);
16600 }
16601 {
16602 if (!wxPyCheckForApp()) SWIG_fail;
16603 PyThreadState* __tstate = wxPyBeginAllowThreads();
16604 result = wxImage_ConvertToBitmap(arg1,arg2);
16605 wxPyEndAllowThreads(__tstate);
16606 if (PyErr_Occurred()) SWIG_fail;
16607 }
16608 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16609 return resultobj;
16610 fail:
16611 return NULL;
16612 }
16613
16614
16615 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16616 PyObject *resultobj = 0;
16617 wxImage *arg1 = (wxImage *) 0 ;
16618 byte arg2 ;
16619 byte arg3 ;
16620 byte arg4 ;
16621 wxBitmap result;
16622 void *argp1 = 0 ;
16623 int res1 = 0 ;
16624 unsigned char val2 ;
16625 int ecode2 = 0 ;
16626 unsigned char val3 ;
16627 int ecode3 = 0 ;
16628 unsigned char val4 ;
16629 int ecode4 = 0 ;
16630 PyObject * obj0 = 0 ;
16631 PyObject * obj1 = 0 ;
16632 PyObject * obj2 = 0 ;
16633 PyObject * obj3 = 0 ;
16634 char * kwnames[] = {
16635 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16636 };
16637
16638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16640 if (!SWIG_IsOK(res1)) {
16641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16642 }
16643 arg1 = reinterpret_cast< wxImage * >(argp1);
16644 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16645 if (!SWIG_IsOK(ecode2)) {
16646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16647 }
16648 arg2 = static_cast< byte >(val2);
16649 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16650 if (!SWIG_IsOK(ecode3)) {
16651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16652 }
16653 arg3 = static_cast< byte >(val3);
16654 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16655 if (!SWIG_IsOK(ecode4)) {
16656 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16657 }
16658 arg4 = static_cast< byte >(val4);
16659 {
16660 if (!wxPyCheckForApp()) SWIG_fail;
16661 PyThreadState* __tstate = wxPyBeginAllowThreads();
16662 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16663 wxPyEndAllowThreads(__tstate);
16664 if (PyErr_Occurred()) SWIG_fail;
16665 }
16666 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16667 return resultobj;
16668 fail:
16669 return NULL;
16670 }
16671
16672
16673 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16674 PyObject *resultobj = 0;
16675 wxImage *arg1 = (wxImage *) 0 ;
16676 double arg2 ;
16677 void *argp1 = 0 ;
16678 int res1 = 0 ;
16679 double val2 ;
16680 int ecode2 = 0 ;
16681 PyObject * obj0 = 0 ;
16682 PyObject * obj1 = 0 ;
16683 char * kwnames[] = {
16684 (char *) "self",(char *) "angle", NULL
16685 };
16686
16687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16689 if (!SWIG_IsOK(res1)) {
16690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16691 }
16692 arg1 = reinterpret_cast< wxImage * >(argp1);
16693 ecode2 = SWIG_AsVal_double(obj1, &val2);
16694 if (!SWIG_IsOK(ecode2)) {
16695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16696 }
16697 arg2 = static_cast< double >(val2);
16698 {
16699 PyThreadState* __tstate = wxPyBeginAllowThreads();
16700 (arg1)->RotateHue(arg2);
16701 wxPyEndAllowThreads(__tstate);
16702 if (PyErr_Occurred()) SWIG_fail;
16703 }
16704 resultobj = SWIG_Py_Void();
16705 return resultobj;
16706 fail:
16707 return NULL;
16708 }
16709
16710
16711 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16712 PyObject *resultobj = 0;
16713 wxImage_RGBValue arg1 ;
16714 wxImage_HSVValue result;
16715 void *argp1 ;
16716 int res1 = 0 ;
16717 PyObject * obj0 = 0 ;
16718 char * kwnames[] = {
16719 (char *) "rgb", NULL
16720 };
16721
16722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16723 {
16724 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16725 if (!SWIG_IsOK(res1)) {
16726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16727 }
16728 if (!argp1) {
16729 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16730 } else {
16731 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16732 arg1 = *temp;
16733 if (SWIG_IsNewObj(res1)) delete temp;
16734 }
16735 }
16736 {
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 result = wxImage::RGBtoHSV(arg1);
16739 wxPyEndAllowThreads(__tstate);
16740 if (PyErr_Occurred()) SWIG_fail;
16741 }
16742 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16743 return resultobj;
16744 fail:
16745 return NULL;
16746 }
16747
16748
16749 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16750 PyObject *resultobj = 0;
16751 wxImage_HSVValue arg1 ;
16752 wxImage_RGBValue result;
16753 void *argp1 ;
16754 int res1 = 0 ;
16755 PyObject * obj0 = 0 ;
16756 char * kwnames[] = {
16757 (char *) "hsv", NULL
16758 };
16759
16760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16761 {
16762 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16763 if (!SWIG_IsOK(res1)) {
16764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16765 }
16766 if (!argp1) {
16767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16768 } else {
16769 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16770 arg1 = *temp;
16771 if (SWIG_IsNewObj(res1)) delete temp;
16772 }
16773 }
16774 {
16775 PyThreadState* __tstate = wxPyBeginAllowThreads();
16776 result = wxImage::HSVtoRGB(arg1);
16777 wxPyEndAllowThreads(__tstate);
16778 if (PyErr_Occurred()) SWIG_fail;
16779 }
16780 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16781 return resultobj;
16782 fail:
16783 return NULL;
16784 }
16785
16786
16787 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16788 PyObject *obj;
16789 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16790 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16791 return SWIG_Py_Void();
16792 }
16793
16794 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16795 return SWIG_Python_InitShadowInstance(args);
16796 }
16797
16798 SWIGINTERN int NullImage_set(PyObject *) {
16799 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16800 return 1;
16801 }
16802
16803
16804 SWIGINTERN PyObject *NullImage_get(void) {
16805 PyObject *pyobj = 0;
16806
16807 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16808 return pyobj;
16809 }
16810
16811
16812 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16813 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16814 return 1;
16815 }
16816
16817
16818 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16819 PyObject *pyobj = 0;
16820
16821 {
16822 #if wxUSE_UNICODE
16823 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16824 #else
16825 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16826 #endif
16827 }
16828 return pyobj;
16829 }
16830
16831
16832 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16833 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16834 return 1;
16835 }
16836
16837
16838 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16839 PyObject *pyobj = 0;
16840
16841 {
16842 #if wxUSE_UNICODE
16843 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16844 #else
16845 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16846 #endif
16847 }
16848 return pyobj;
16849 }
16850
16851
16852 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16853 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16854 return 1;
16855 }
16856
16857
16858 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16859 PyObject *pyobj = 0;
16860
16861 {
16862 #if wxUSE_UNICODE
16863 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16864 #else
16865 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16866 #endif
16867 }
16868 return pyobj;
16869 }
16870
16871
16872 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16873 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16874 return 1;
16875 }
16876
16877
16878 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16879 PyObject *pyobj = 0;
16880
16881 {
16882 #if wxUSE_UNICODE
16883 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16884 #else
16885 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16886 #endif
16887 }
16888 return pyobj;
16889 }
16890
16891
16892 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16893 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16894 return 1;
16895 }
16896
16897
16898 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16899 PyObject *pyobj = 0;
16900
16901 {
16902 #if wxUSE_UNICODE
16903 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16904 #else
16905 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16906 #endif
16907 }
16908 return pyobj;
16909 }
16910
16911
16912 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16913 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16914 return 1;
16915 }
16916
16917
16918 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16919 PyObject *pyobj = 0;
16920
16921 {
16922 #if wxUSE_UNICODE
16923 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16924 #else
16925 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16926 #endif
16927 }
16928 return pyobj;
16929 }
16930
16931
16932 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16933 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16934 return 1;
16935 }
16936
16937
16938 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16939 PyObject *pyobj = 0;
16940
16941 {
16942 #if wxUSE_UNICODE
16943 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16944 #else
16945 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16946 #endif
16947 }
16948 return pyobj;
16949 }
16950
16951
16952 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
16953 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
16954 return 1;
16955 }
16956
16957
16958 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
16959 PyObject *pyobj = 0;
16960
16961 {
16962 #if wxUSE_UNICODE
16963 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16964 #else
16965 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16966 #endif
16967 }
16968 return pyobj;
16969 }
16970
16971
16972 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
16973 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
16974 return 1;
16975 }
16976
16977
16978 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
16979 PyObject *pyobj = 0;
16980
16981 {
16982 #if wxUSE_UNICODE
16983 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16984 #else
16985 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16986 #endif
16987 }
16988 return pyobj;
16989 }
16990
16991
16992 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
16993 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
16994 return 1;
16995 }
16996
16997
16998 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
16999 PyObject *pyobj = 0;
17000
17001 {
17002 #if wxUSE_UNICODE
17003 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17004 #else
17005 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17006 #endif
17007 }
17008 return pyobj;
17009 }
17010
17011
17012 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17013 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17014 return 1;
17015 }
17016
17017
17018 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17019 PyObject *pyobj = 0;
17020
17021 {
17022 #if wxUSE_UNICODE
17023 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17024 #else
17025 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17026 #endif
17027 }
17028 return pyobj;
17029 }
17030
17031
17032 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17033 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17034 return 1;
17035 }
17036
17037
17038 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17039 PyObject *pyobj = 0;
17040
17041 {
17042 #if wxUSE_UNICODE
17043 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17044 #else
17045 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17046 #endif
17047 }
17048 return pyobj;
17049 }
17050
17051
17052 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17053 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17054 return 1;
17055 }
17056
17057
17058 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17059 PyObject *pyobj = 0;
17060
17061 {
17062 #if wxUSE_UNICODE
17063 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17064 #else
17065 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17066 #endif
17067 }
17068 return pyobj;
17069 }
17070
17071
17072 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17073 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17074 return 1;
17075 }
17076
17077
17078 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17079 PyObject *pyobj = 0;
17080
17081 {
17082 #if wxUSE_UNICODE
17083 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17084 #else
17085 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17086 #endif
17087 }
17088 return pyobj;
17089 }
17090
17091
17092 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17093 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17094 return 1;
17095 }
17096
17097
17098 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17099 PyObject *pyobj = 0;
17100
17101 {
17102 #if wxUSE_UNICODE
17103 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17104 #else
17105 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17106 #endif
17107 }
17108 return pyobj;
17109 }
17110
17111
17112 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17113 PyObject *resultobj = 0;
17114 wxBMPHandler *result = 0 ;
17115
17116 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17117 {
17118 PyThreadState* __tstate = wxPyBeginAllowThreads();
17119 result = (wxBMPHandler *)new wxBMPHandler();
17120 wxPyEndAllowThreads(__tstate);
17121 if (PyErr_Occurred()) SWIG_fail;
17122 }
17123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17124 return resultobj;
17125 fail:
17126 return NULL;
17127 }
17128
17129
17130 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17131 PyObject *obj;
17132 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17133 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17134 return SWIG_Py_Void();
17135 }
17136
17137 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17138 return SWIG_Python_InitShadowInstance(args);
17139 }
17140
17141 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17142 PyObject *resultobj = 0;
17143 wxICOHandler *result = 0 ;
17144
17145 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17146 {
17147 PyThreadState* __tstate = wxPyBeginAllowThreads();
17148 result = (wxICOHandler *)new wxICOHandler();
17149 wxPyEndAllowThreads(__tstate);
17150 if (PyErr_Occurred()) SWIG_fail;
17151 }
17152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17153 return resultobj;
17154 fail:
17155 return NULL;
17156 }
17157
17158
17159 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17160 PyObject *obj;
17161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17162 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17163 return SWIG_Py_Void();
17164 }
17165
17166 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17167 return SWIG_Python_InitShadowInstance(args);
17168 }
17169
17170 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17171 PyObject *resultobj = 0;
17172 wxCURHandler *result = 0 ;
17173
17174 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17175 {
17176 PyThreadState* __tstate = wxPyBeginAllowThreads();
17177 result = (wxCURHandler *)new wxCURHandler();
17178 wxPyEndAllowThreads(__tstate);
17179 if (PyErr_Occurred()) SWIG_fail;
17180 }
17181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17182 return resultobj;
17183 fail:
17184 return NULL;
17185 }
17186
17187
17188 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17189 PyObject *obj;
17190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17191 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17192 return SWIG_Py_Void();
17193 }
17194
17195 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17196 return SWIG_Python_InitShadowInstance(args);
17197 }
17198
17199 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17200 PyObject *resultobj = 0;
17201 wxANIHandler *result = 0 ;
17202
17203 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17204 {
17205 PyThreadState* __tstate = wxPyBeginAllowThreads();
17206 result = (wxANIHandler *)new wxANIHandler();
17207 wxPyEndAllowThreads(__tstate);
17208 if (PyErr_Occurred()) SWIG_fail;
17209 }
17210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17211 return resultobj;
17212 fail:
17213 return NULL;
17214 }
17215
17216
17217 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17218 PyObject *obj;
17219 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17220 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17221 return SWIG_Py_Void();
17222 }
17223
17224 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17225 return SWIG_Python_InitShadowInstance(args);
17226 }
17227
17228 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17229 PyObject *resultobj = 0;
17230 wxPNGHandler *result = 0 ;
17231
17232 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17233 {
17234 PyThreadState* __tstate = wxPyBeginAllowThreads();
17235 result = (wxPNGHandler *)new wxPNGHandler();
17236 wxPyEndAllowThreads(__tstate);
17237 if (PyErr_Occurred()) SWIG_fail;
17238 }
17239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17240 return resultobj;
17241 fail:
17242 return NULL;
17243 }
17244
17245
17246 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17247 PyObject *obj;
17248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17249 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17250 return SWIG_Py_Void();
17251 }
17252
17253 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17254 return SWIG_Python_InitShadowInstance(args);
17255 }
17256
17257 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17258 PyObject *resultobj = 0;
17259 wxGIFHandler *result = 0 ;
17260
17261 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17262 {
17263 PyThreadState* __tstate = wxPyBeginAllowThreads();
17264 result = (wxGIFHandler *)new wxGIFHandler();
17265 wxPyEndAllowThreads(__tstate);
17266 if (PyErr_Occurred()) SWIG_fail;
17267 }
17268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17269 return resultobj;
17270 fail:
17271 return NULL;
17272 }
17273
17274
17275 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17276 PyObject *obj;
17277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17278 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17279 return SWIG_Py_Void();
17280 }
17281
17282 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17283 return SWIG_Python_InitShadowInstance(args);
17284 }
17285
17286 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17287 PyObject *resultobj = 0;
17288 wxPCXHandler *result = 0 ;
17289
17290 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17291 {
17292 PyThreadState* __tstate = wxPyBeginAllowThreads();
17293 result = (wxPCXHandler *)new wxPCXHandler();
17294 wxPyEndAllowThreads(__tstate);
17295 if (PyErr_Occurred()) SWIG_fail;
17296 }
17297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17298 return resultobj;
17299 fail:
17300 return NULL;
17301 }
17302
17303
17304 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17305 PyObject *obj;
17306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17307 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17308 return SWIG_Py_Void();
17309 }
17310
17311 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17312 return SWIG_Python_InitShadowInstance(args);
17313 }
17314
17315 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17316 PyObject *resultobj = 0;
17317 wxJPEGHandler *result = 0 ;
17318
17319 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17320 {
17321 PyThreadState* __tstate = wxPyBeginAllowThreads();
17322 result = (wxJPEGHandler *)new wxJPEGHandler();
17323 wxPyEndAllowThreads(__tstate);
17324 if (PyErr_Occurred()) SWIG_fail;
17325 }
17326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17327 return resultobj;
17328 fail:
17329 return NULL;
17330 }
17331
17332
17333 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17334 PyObject *obj;
17335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17336 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17337 return SWIG_Py_Void();
17338 }
17339
17340 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17341 return SWIG_Python_InitShadowInstance(args);
17342 }
17343
17344 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17345 PyObject *resultobj = 0;
17346 wxPNMHandler *result = 0 ;
17347
17348 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17349 {
17350 PyThreadState* __tstate = wxPyBeginAllowThreads();
17351 result = (wxPNMHandler *)new wxPNMHandler();
17352 wxPyEndAllowThreads(__tstate);
17353 if (PyErr_Occurred()) SWIG_fail;
17354 }
17355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17356 return resultobj;
17357 fail:
17358 return NULL;
17359 }
17360
17361
17362 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17363 PyObject *obj;
17364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17365 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17366 return SWIG_Py_Void();
17367 }
17368
17369 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17370 return SWIG_Python_InitShadowInstance(args);
17371 }
17372
17373 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17374 PyObject *resultobj = 0;
17375 wxXPMHandler *result = 0 ;
17376
17377 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17378 {
17379 PyThreadState* __tstate = wxPyBeginAllowThreads();
17380 result = (wxXPMHandler *)new wxXPMHandler();
17381 wxPyEndAllowThreads(__tstate);
17382 if (PyErr_Occurred()) SWIG_fail;
17383 }
17384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17385 return resultobj;
17386 fail:
17387 return NULL;
17388 }
17389
17390
17391 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17392 PyObject *obj;
17393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17394 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17395 return SWIG_Py_Void();
17396 }
17397
17398 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17399 return SWIG_Python_InitShadowInstance(args);
17400 }
17401
17402 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17403 PyObject *resultobj = 0;
17404 wxTIFFHandler *result = 0 ;
17405
17406 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17407 {
17408 PyThreadState* __tstate = wxPyBeginAllowThreads();
17409 result = (wxTIFFHandler *)new wxTIFFHandler();
17410 wxPyEndAllowThreads(__tstate);
17411 if (PyErr_Occurred()) SWIG_fail;
17412 }
17413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17414 return resultobj;
17415 fail:
17416 return NULL;
17417 }
17418
17419
17420 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17421 PyObject *obj;
17422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17423 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17424 return SWIG_Py_Void();
17425 }
17426
17427 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17428 return SWIG_Python_InitShadowInstance(args);
17429 }
17430
17431 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17432 PyObject *resultobj = 0;
17433 wxImage *arg1 = 0 ;
17434 wxImage *arg2 = 0 ;
17435 int arg3 = (int) 236 ;
17436 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17437 bool result;
17438 void *argp1 = 0 ;
17439 int res1 = 0 ;
17440 void *argp2 = 0 ;
17441 int res2 = 0 ;
17442 int val3 ;
17443 int ecode3 = 0 ;
17444 int val4 ;
17445 int ecode4 = 0 ;
17446 PyObject * obj0 = 0 ;
17447 PyObject * obj1 = 0 ;
17448 PyObject * obj2 = 0 ;
17449 PyObject * obj3 = 0 ;
17450 char * kwnames[] = {
17451 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17452 };
17453
17454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17455 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17456 if (!SWIG_IsOK(res1)) {
17457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17458 }
17459 if (!argp1) {
17460 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17461 }
17462 arg1 = reinterpret_cast< wxImage * >(argp1);
17463 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17464 if (!SWIG_IsOK(res2)) {
17465 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17466 }
17467 if (!argp2) {
17468 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17469 }
17470 arg2 = reinterpret_cast< wxImage * >(argp2);
17471 if (obj2) {
17472 ecode3 = SWIG_AsVal_int(obj2, &val3);
17473 if (!SWIG_IsOK(ecode3)) {
17474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17475 }
17476 arg3 = static_cast< int >(val3);
17477 }
17478 if (obj3) {
17479 ecode4 = SWIG_AsVal_int(obj3, &val4);
17480 if (!SWIG_IsOK(ecode4)) {
17481 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17482 }
17483 arg4 = static_cast< int >(val4);
17484 }
17485 {
17486 PyThreadState* __tstate = wxPyBeginAllowThreads();
17487 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17488 wxPyEndAllowThreads(__tstate);
17489 if (PyErr_Occurred()) SWIG_fail;
17490 }
17491 {
17492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17493 }
17494 return resultobj;
17495 fail:
17496 return NULL;
17497 }
17498
17499
17500 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17501 PyObject *obj;
17502 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17503 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17504 return SWIG_Py_Void();
17505 }
17506
17507 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17508 PyObject *resultobj = 0;
17509 wxEvtHandler *result = 0 ;
17510
17511 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17512 {
17513 PyThreadState* __tstate = wxPyBeginAllowThreads();
17514 result = (wxEvtHandler *)new wxEvtHandler();
17515 wxPyEndAllowThreads(__tstate);
17516 if (PyErr_Occurred()) SWIG_fail;
17517 }
17518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17519 return resultobj;
17520 fail:
17521 return NULL;
17522 }
17523
17524
17525 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17526 PyObject *resultobj = 0;
17527 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17528 wxEvtHandler *result = 0 ;
17529 void *argp1 = 0 ;
17530 int res1 = 0 ;
17531 PyObject *swig_obj[1] ;
17532
17533 if (!args) SWIG_fail;
17534 swig_obj[0] = args;
17535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17536 if (!SWIG_IsOK(res1)) {
17537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17538 }
17539 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17540 {
17541 PyThreadState* __tstate = wxPyBeginAllowThreads();
17542 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17543 wxPyEndAllowThreads(__tstate);
17544 if (PyErr_Occurred()) SWIG_fail;
17545 }
17546 {
17547 resultobj = wxPyMake_wxObject(result, 0);
17548 }
17549 return resultobj;
17550 fail:
17551 return NULL;
17552 }
17553
17554
17555 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17556 PyObject *resultobj = 0;
17557 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17558 wxEvtHandler *result = 0 ;
17559 void *argp1 = 0 ;
17560 int res1 = 0 ;
17561 PyObject *swig_obj[1] ;
17562
17563 if (!args) SWIG_fail;
17564 swig_obj[0] = args;
17565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17566 if (!SWIG_IsOK(res1)) {
17567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17568 }
17569 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17570 {
17571 PyThreadState* __tstate = wxPyBeginAllowThreads();
17572 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17573 wxPyEndAllowThreads(__tstate);
17574 if (PyErr_Occurred()) SWIG_fail;
17575 }
17576 {
17577 resultobj = wxPyMake_wxObject(result, 0);
17578 }
17579 return resultobj;
17580 fail:
17581 return NULL;
17582 }
17583
17584
17585 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17586 PyObject *resultobj = 0;
17587 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17588 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17589 void *argp1 = 0 ;
17590 int res1 = 0 ;
17591 void *argp2 = 0 ;
17592 int res2 = 0 ;
17593 PyObject * obj0 = 0 ;
17594 PyObject * obj1 = 0 ;
17595 char * kwnames[] = {
17596 (char *) "self",(char *) "handler", NULL
17597 };
17598
17599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17601 if (!SWIG_IsOK(res1)) {
17602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17603 }
17604 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17605 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17606 if (!SWIG_IsOK(res2)) {
17607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17608 }
17609 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17610 {
17611 PyThreadState* __tstate = wxPyBeginAllowThreads();
17612 (arg1)->SetNextHandler(arg2);
17613 wxPyEndAllowThreads(__tstate);
17614 if (PyErr_Occurred()) SWIG_fail;
17615 }
17616 resultobj = SWIG_Py_Void();
17617 return resultobj;
17618 fail:
17619 return NULL;
17620 }
17621
17622
17623 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17624 PyObject *resultobj = 0;
17625 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17626 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17627 void *argp1 = 0 ;
17628 int res1 = 0 ;
17629 void *argp2 = 0 ;
17630 int res2 = 0 ;
17631 PyObject * obj0 = 0 ;
17632 PyObject * obj1 = 0 ;
17633 char * kwnames[] = {
17634 (char *) "self",(char *) "handler", NULL
17635 };
17636
17637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17639 if (!SWIG_IsOK(res1)) {
17640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17641 }
17642 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17643 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17644 if (!SWIG_IsOK(res2)) {
17645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17646 }
17647 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17648 {
17649 PyThreadState* __tstate = wxPyBeginAllowThreads();
17650 (arg1)->SetPreviousHandler(arg2);
17651 wxPyEndAllowThreads(__tstate);
17652 if (PyErr_Occurred()) SWIG_fail;
17653 }
17654 resultobj = SWIG_Py_Void();
17655 return resultobj;
17656 fail:
17657 return NULL;
17658 }
17659
17660
17661 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17662 PyObject *resultobj = 0;
17663 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17664 bool result;
17665 void *argp1 = 0 ;
17666 int res1 = 0 ;
17667 PyObject *swig_obj[1] ;
17668
17669 if (!args) SWIG_fail;
17670 swig_obj[0] = args;
17671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17672 if (!SWIG_IsOK(res1)) {
17673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17674 }
17675 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17676 {
17677 PyThreadState* __tstate = wxPyBeginAllowThreads();
17678 result = (bool)(arg1)->GetEvtHandlerEnabled();
17679 wxPyEndAllowThreads(__tstate);
17680 if (PyErr_Occurred()) SWIG_fail;
17681 }
17682 {
17683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17684 }
17685 return resultobj;
17686 fail:
17687 return NULL;
17688 }
17689
17690
17691 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17692 PyObject *resultobj = 0;
17693 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17694 bool arg2 ;
17695 void *argp1 = 0 ;
17696 int res1 = 0 ;
17697 bool val2 ;
17698 int ecode2 = 0 ;
17699 PyObject * obj0 = 0 ;
17700 PyObject * obj1 = 0 ;
17701 char * kwnames[] = {
17702 (char *) "self",(char *) "enabled", NULL
17703 };
17704
17705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17707 if (!SWIG_IsOK(res1)) {
17708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17709 }
17710 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17711 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17712 if (!SWIG_IsOK(ecode2)) {
17713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17714 }
17715 arg2 = static_cast< bool >(val2);
17716 {
17717 PyThreadState* __tstate = wxPyBeginAllowThreads();
17718 (arg1)->SetEvtHandlerEnabled(arg2);
17719 wxPyEndAllowThreads(__tstate);
17720 if (PyErr_Occurred()) SWIG_fail;
17721 }
17722 resultobj = SWIG_Py_Void();
17723 return resultobj;
17724 fail:
17725 return NULL;
17726 }
17727
17728
17729 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17730 PyObject *resultobj = 0;
17731 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17732 wxEvent *arg2 = 0 ;
17733 bool result;
17734 void *argp1 = 0 ;
17735 int res1 = 0 ;
17736 void *argp2 = 0 ;
17737 int res2 = 0 ;
17738 PyObject * obj0 = 0 ;
17739 PyObject * obj1 = 0 ;
17740 char * kwnames[] = {
17741 (char *) "self",(char *) "event", NULL
17742 };
17743
17744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17746 if (!SWIG_IsOK(res1)) {
17747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17748 }
17749 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17750 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17751 if (!SWIG_IsOK(res2)) {
17752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17753 }
17754 if (!argp2) {
17755 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17756 }
17757 arg2 = reinterpret_cast< wxEvent * >(argp2);
17758 {
17759 PyThreadState* __tstate = wxPyBeginAllowThreads();
17760 result = (bool)(arg1)->ProcessEvent(*arg2);
17761 wxPyEndAllowThreads(__tstate);
17762 if (PyErr_Occurred()) SWIG_fail;
17763 }
17764 {
17765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17766 }
17767 return resultobj;
17768 fail:
17769 return NULL;
17770 }
17771
17772
17773 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17774 PyObject *resultobj = 0;
17775 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17776 wxEvent *arg2 = 0 ;
17777 void *argp1 = 0 ;
17778 int res1 = 0 ;
17779 void *argp2 = 0 ;
17780 int res2 = 0 ;
17781 PyObject * obj0 = 0 ;
17782 PyObject * obj1 = 0 ;
17783 char * kwnames[] = {
17784 (char *) "self",(char *) "event", NULL
17785 };
17786
17787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17789 if (!SWIG_IsOK(res1)) {
17790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17791 }
17792 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17793 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17794 if (!SWIG_IsOK(res2)) {
17795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17796 }
17797 if (!argp2) {
17798 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17799 }
17800 arg2 = reinterpret_cast< wxEvent * >(argp2);
17801 {
17802 PyThreadState* __tstate = wxPyBeginAllowThreads();
17803 (arg1)->AddPendingEvent(*arg2);
17804 wxPyEndAllowThreads(__tstate);
17805 if (PyErr_Occurred()) SWIG_fail;
17806 }
17807 resultobj = SWIG_Py_Void();
17808 return resultobj;
17809 fail:
17810 return NULL;
17811 }
17812
17813
17814 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17815 PyObject *resultobj = 0;
17816 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17817 void *argp1 = 0 ;
17818 int res1 = 0 ;
17819 PyObject *swig_obj[1] ;
17820
17821 if (!args) SWIG_fail;
17822 swig_obj[0] = args;
17823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17824 if (!SWIG_IsOK(res1)) {
17825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17826 }
17827 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17828 {
17829 PyThreadState* __tstate = wxPyBeginAllowThreads();
17830 (arg1)->ProcessPendingEvents();
17831 wxPyEndAllowThreads(__tstate);
17832 if (PyErr_Occurred()) SWIG_fail;
17833 }
17834 resultobj = SWIG_Py_Void();
17835 return resultobj;
17836 fail:
17837 return NULL;
17838 }
17839
17840
17841 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17842 PyObject *resultobj = 0;
17843 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17844 int arg2 ;
17845 int arg3 ;
17846 int arg4 ;
17847 PyObject *arg5 = (PyObject *) 0 ;
17848 void *argp1 = 0 ;
17849 int res1 = 0 ;
17850 int val2 ;
17851 int ecode2 = 0 ;
17852 int val3 ;
17853 int ecode3 = 0 ;
17854 int val4 ;
17855 int ecode4 = 0 ;
17856 PyObject * obj0 = 0 ;
17857 PyObject * obj1 = 0 ;
17858 PyObject * obj2 = 0 ;
17859 PyObject * obj3 = 0 ;
17860 PyObject * obj4 = 0 ;
17861 char * kwnames[] = {
17862 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17863 };
17864
17865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17867 if (!SWIG_IsOK(res1)) {
17868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17869 }
17870 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17871 ecode2 = SWIG_AsVal_int(obj1, &val2);
17872 if (!SWIG_IsOK(ecode2)) {
17873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17874 }
17875 arg2 = static_cast< int >(val2);
17876 ecode3 = SWIG_AsVal_int(obj2, &val3);
17877 if (!SWIG_IsOK(ecode3)) {
17878 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17879 }
17880 arg3 = static_cast< int >(val3);
17881 ecode4 = SWIG_AsVal_int(obj3, &val4);
17882 if (!SWIG_IsOK(ecode4)) {
17883 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17884 }
17885 arg4 = static_cast< int >(val4);
17886 arg5 = obj4;
17887 {
17888 PyThreadState* __tstate = wxPyBeginAllowThreads();
17889 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17890 wxPyEndAllowThreads(__tstate);
17891 if (PyErr_Occurred()) SWIG_fail;
17892 }
17893 resultobj = SWIG_Py_Void();
17894 return resultobj;
17895 fail:
17896 return NULL;
17897 }
17898
17899
17900 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17901 PyObject *resultobj = 0;
17902 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17903 int arg2 ;
17904 int arg3 = (int) -1 ;
17905 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17906 bool result;
17907 void *argp1 = 0 ;
17908 int res1 = 0 ;
17909 int val2 ;
17910 int ecode2 = 0 ;
17911 int val3 ;
17912 int ecode3 = 0 ;
17913 int val4 ;
17914 int ecode4 = 0 ;
17915 PyObject * obj0 = 0 ;
17916 PyObject * obj1 = 0 ;
17917 PyObject * obj2 = 0 ;
17918 PyObject * obj3 = 0 ;
17919 char * kwnames[] = {
17920 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17921 };
17922
17923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17925 if (!SWIG_IsOK(res1)) {
17926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17927 }
17928 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17929 ecode2 = SWIG_AsVal_int(obj1, &val2);
17930 if (!SWIG_IsOK(ecode2)) {
17931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17932 }
17933 arg2 = static_cast< int >(val2);
17934 if (obj2) {
17935 ecode3 = SWIG_AsVal_int(obj2, &val3);
17936 if (!SWIG_IsOK(ecode3)) {
17937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17938 }
17939 arg3 = static_cast< int >(val3);
17940 }
17941 if (obj3) {
17942 ecode4 = SWIG_AsVal_int(obj3, &val4);
17943 if (!SWIG_IsOK(ecode4)) {
17944 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
17945 }
17946 arg4 = static_cast< wxEventType >(val4);
17947 }
17948 {
17949 PyThreadState* __tstate = wxPyBeginAllowThreads();
17950 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
17951 wxPyEndAllowThreads(__tstate);
17952 if (PyErr_Occurred()) SWIG_fail;
17953 }
17954 {
17955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17956 }
17957 return resultobj;
17958 fail:
17959 return NULL;
17960 }
17961
17962
17963 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17964 PyObject *resultobj = 0;
17965 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17966 PyObject *arg2 = (PyObject *) 0 ;
17967 bool arg3 = (bool) true ;
17968 void *argp1 = 0 ;
17969 int res1 = 0 ;
17970 bool val3 ;
17971 int ecode3 = 0 ;
17972 PyObject * obj0 = 0 ;
17973 PyObject * obj1 = 0 ;
17974 PyObject * obj2 = 0 ;
17975 char * kwnames[] = {
17976 (char *) "self",(char *) "_self",(char *) "incref", NULL
17977 };
17978
17979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17981 if (!SWIG_IsOK(res1)) {
17982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17983 }
17984 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17985 arg2 = obj1;
17986 if (obj2) {
17987 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17988 if (!SWIG_IsOK(ecode3)) {
17989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
17990 }
17991 arg3 = static_cast< bool >(val3);
17992 }
17993 {
17994 PyThreadState* __tstate = wxPyBeginAllowThreads();
17995 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
17996 wxPyEndAllowThreads(__tstate);
17997 if (PyErr_Occurred()) SWIG_fail;
17998 }
17999 resultobj = SWIG_Py_Void();
18000 return resultobj;
18001 fail:
18002 return NULL;
18003 }
18004
18005
18006 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18007 PyObject *obj;
18008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18009 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18010 return SWIG_Py_Void();
18011 }
18012
18013 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18014 return SWIG_Python_InitShadowInstance(args);
18015 }
18016
18017 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18018 PyObject *resultobj = 0;
18019 wxEventType result;
18020
18021 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18022 {
18023 PyThreadState* __tstate = wxPyBeginAllowThreads();
18024 result = (wxEventType)wxNewEventType();
18025 wxPyEndAllowThreads(__tstate);
18026 if (PyErr_Occurred()) SWIG_fail;
18027 }
18028 resultobj = SWIG_From_int(static_cast< int >(result));
18029 return resultobj;
18030 fail:
18031 return NULL;
18032 }
18033
18034
18035 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18036 PyObject *resultobj = 0;
18037 wxEvent *arg1 = (wxEvent *) 0 ;
18038 void *argp1 = 0 ;
18039 int res1 = 0 ;
18040 PyObject *swig_obj[1] ;
18041
18042 if (!args) SWIG_fail;
18043 swig_obj[0] = args;
18044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18045 if (!SWIG_IsOK(res1)) {
18046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18047 }
18048 arg1 = reinterpret_cast< wxEvent * >(argp1);
18049 {
18050 PyThreadState* __tstate = wxPyBeginAllowThreads();
18051 delete arg1;
18052
18053 wxPyEndAllowThreads(__tstate);
18054 if (PyErr_Occurred()) SWIG_fail;
18055 }
18056 resultobj = SWIG_Py_Void();
18057 return resultobj;
18058 fail:
18059 return NULL;
18060 }
18061
18062
18063 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18064 PyObject *resultobj = 0;
18065 wxEvent *arg1 = (wxEvent *) 0 ;
18066 wxEventType arg2 ;
18067 void *argp1 = 0 ;
18068 int res1 = 0 ;
18069 int val2 ;
18070 int ecode2 = 0 ;
18071 PyObject * obj0 = 0 ;
18072 PyObject * obj1 = 0 ;
18073 char * kwnames[] = {
18074 (char *) "self",(char *) "typ", NULL
18075 };
18076
18077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18079 if (!SWIG_IsOK(res1)) {
18080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18081 }
18082 arg1 = reinterpret_cast< wxEvent * >(argp1);
18083 ecode2 = SWIG_AsVal_int(obj1, &val2);
18084 if (!SWIG_IsOK(ecode2)) {
18085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18086 }
18087 arg2 = static_cast< wxEventType >(val2);
18088 {
18089 PyThreadState* __tstate = wxPyBeginAllowThreads();
18090 (arg1)->SetEventType(arg2);
18091 wxPyEndAllowThreads(__tstate);
18092 if (PyErr_Occurred()) SWIG_fail;
18093 }
18094 resultobj = SWIG_Py_Void();
18095 return resultobj;
18096 fail:
18097 return NULL;
18098 }
18099
18100
18101 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18102 PyObject *resultobj = 0;
18103 wxEvent *arg1 = (wxEvent *) 0 ;
18104 wxEventType result;
18105 void *argp1 = 0 ;
18106 int res1 = 0 ;
18107 PyObject *swig_obj[1] ;
18108
18109 if (!args) SWIG_fail;
18110 swig_obj[0] = args;
18111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18112 if (!SWIG_IsOK(res1)) {
18113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18114 }
18115 arg1 = reinterpret_cast< wxEvent * >(argp1);
18116 {
18117 PyThreadState* __tstate = wxPyBeginAllowThreads();
18118 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18119 wxPyEndAllowThreads(__tstate);
18120 if (PyErr_Occurred()) SWIG_fail;
18121 }
18122 resultobj = SWIG_From_int(static_cast< int >(result));
18123 return resultobj;
18124 fail:
18125 return NULL;
18126 }
18127
18128
18129 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18130 PyObject *resultobj = 0;
18131 wxEvent *arg1 = (wxEvent *) 0 ;
18132 wxObject *result = 0 ;
18133 void *argp1 = 0 ;
18134 int res1 = 0 ;
18135 PyObject *swig_obj[1] ;
18136
18137 if (!args) SWIG_fail;
18138 swig_obj[0] = args;
18139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18140 if (!SWIG_IsOK(res1)) {
18141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18142 }
18143 arg1 = reinterpret_cast< wxEvent * >(argp1);
18144 {
18145 PyThreadState* __tstate = wxPyBeginAllowThreads();
18146 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18147 wxPyEndAllowThreads(__tstate);
18148 if (PyErr_Occurred()) SWIG_fail;
18149 }
18150 {
18151 resultobj = wxPyMake_wxObject(result, (bool)0);
18152 }
18153 return resultobj;
18154 fail:
18155 return NULL;
18156 }
18157
18158
18159 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18160 PyObject *resultobj = 0;
18161 wxEvent *arg1 = (wxEvent *) 0 ;
18162 wxObject *arg2 = (wxObject *) 0 ;
18163 void *argp1 = 0 ;
18164 int res1 = 0 ;
18165 void *argp2 = 0 ;
18166 int res2 = 0 ;
18167 PyObject * obj0 = 0 ;
18168 PyObject * obj1 = 0 ;
18169 char * kwnames[] = {
18170 (char *) "self",(char *) "obj", NULL
18171 };
18172
18173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18175 if (!SWIG_IsOK(res1)) {
18176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18177 }
18178 arg1 = reinterpret_cast< wxEvent * >(argp1);
18179 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18180 if (!SWIG_IsOK(res2)) {
18181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18182 }
18183 arg2 = reinterpret_cast< wxObject * >(argp2);
18184 {
18185 PyThreadState* __tstate = wxPyBeginAllowThreads();
18186 (arg1)->SetEventObject(arg2);
18187 wxPyEndAllowThreads(__tstate);
18188 if (PyErr_Occurred()) SWIG_fail;
18189 }
18190 resultobj = SWIG_Py_Void();
18191 return resultobj;
18192 fail:
18193 return NULL;
18194 }
18195
18196
18197 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18198 PyObject *resultobj = 0;
18199 wxEvent *arg1 = (wxEvent *) 0 ;
18200 long result;
18201 void *argp1 = 0 ;
18202 int res1 = 0 ;
18203 PyObject *swig_obj[1] ;
18204
18205 if (!args) SWIG_fail;
18206 swig_obj[0] = args;
18207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18208 if (!SWIG_IsOK(res1)) {
18209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18210 }
18211 arg1 = reinterpret_cast< wxEvent * >(argp1);
18212 {
18213 PyThreadState* __tstate = wxPyBeginAllowThreads();
18214 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18215 wxPyEndAllowThreads(__tstate);
18216 if (PyErr_Occurred()) SWIG_fail;
18217 }
18218 resultobj = SWIG_From_long(static_cast< long >(result));
18219 return resultobj;
18220 fail:
18221 return NULL;
18222 }
18223
18224
18225 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18226 PyObject *resultobj = 0;
18227 wxEvent *arg1 = (wxEvent *) 0 ;
18228 long arg2 = (long) 0 ;
18229 void *argp1 = 0 ;
18230 int res1 = 0 ;
18231 long val2 ;
18232 int ecode2 = 0 ;
18233 PyObject * obj0 = 0 ;
18234 PyObject * obj1 = 0 ;
18235 char * kwnames[] = {
18236 (char *) "self",(char *) "ts", NULL
18237 };
18238
18239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18241 if (!SWIG_IsOK(res1)) {
18242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18243 }
18244 arg1 = reinterpret_cast< wxEvent * >(argp1);
18245 if (obj1) {
18246 ecode2 = SWIG_AsVal_long(obj1, &val2);
18247 if (!SWIG_IsOK(ecode2)) {
18248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18249 }
18250 arg2 = static_cast< long >(val2);
18251 }
18252 {
18253 PyThreadState* __tstate = wxPyBeginAllowThreads();
18254 (arg1)->SetTimestamp(arg2);
18255 wxPyEndAllowThreads(__tstate);
18256 if (PyErr_Occurred()) SWIG_fail;
18257 }
18258 resultobj = SWIG_Py_Void();
18259 return resultobj;
18260 fail:
18261 return NULL;
18262 }
18263
18264
18265 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18266 PyObject *resultobj = 0;
18267 wxEvent *arg1 = (wxEvent *) 0 ;
18268 int result;
18269 void *argp1 = 0 ;
18270 int res1 = 0 ;
18271 PyObject *swig_obj[1] ;
18272
18273 if (!args) SWIG_fail;
18274 swig_obj[0] = args;
18275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18276 if (!SWIG_IsOK(res1)) {
18277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18278 }
18279 arg1 = reinterpret_cast< wxEvent * >(argp1);
18280 {
18281 PyThreadState* __tstate = wxPyBeginAllowThreads();
18282 result = (int)((wxEvent const *)arg1)->GetId();
18283 wxPyEndAllowThreads(__tstate);
18284 if (PyErr_Occurred()) SWIG_fail;
18285 }
18286 resultobj = SWIG_From_int(static_cast< int >(result));
18287 return resultobj;
18288 fail:
18289 return NULL;
18290 }
18291
18292
18293 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18294 PyObject *resultobj = 0;
18295 wxEvent *arg1 = (wxEvent *) 0 ;
18296 int arg2 ;
18297 void *argp1 = 0 ;
18298 int res1 = 0 ;
18299 int val2 ;
18300 int ecode2 = 0 ;
18301 PyObject * obj0 = 0 ;
18302 PyObject * obj1 = 0 ;
18303 char * kwnames[] = {
18304 (char *) "self",(char *) "Id", NULL
18305 };
18306
18307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18309 if (!SWIG_IsOK(res1)) {
18310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18311 }
18312 arg1 = reinterpret_cast< wxEvent * >(argp1);
18313 ecode2 = SWIG_AsVal_int(obj1, &val2);
18314 if (!SWIG_IsOK(ecode2)) {
18315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18316 }
18317 arg2 = static_cast< int >(val2);
18318 {
18319 PyThreadState* __tstate = wxPyBeginAllowThreads();
18320 (arg1)->SetId(arg2);
18321 wxPyEndAllowThreads(__tstate);
18322 if (PyErr_Occurred()) SWIG_fail;
18323 }
18324 resultobj = SWIG_Py_Void();
18325 return resultobj;
18326 fail:
18327 return NULL;
18328 }
18329
18330
18331 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18332 PyObject *resultobj = 0;
18333 wxEvent *arg1 = (wxEvent *) 0 ;
18334 bool result;
18335 void *argp1 = 0 ;
18336 int res1 = 0 ;
18337 PyObject *swig_obj[1] ;
18338
18339 if (!args) SWIG_fail;
18340 swig_obj[0] = args;
18341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18342 if (!SWIG_IsOK(res1)) {
18343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18344 }
18345 arg1 = reinterpret_cast< wxEvent * >(argp1);
18346 {
18347 PyThreadState* __tstate = wxPyBeginAllowThreads();
18348 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18349 wxPyEndAllowThreads(__tstate);
18350 if (PyErr_Occurred()) SWIG_fail;
18351 }
18352 {
18353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18354 }
18355 return resultobj;
18356 fail:
18357 return NULL;
18358 }
18359
18360
18361 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18362 PyObject *resultobj = 0;
18363 wxEvent *arg1 = (wxEvent *) 0 ;
18364 bool arg2 = (bool) true ;
18365 void *argp1 = 0 ;
18366 int res1 = 0 ;
18367 bool val2 ;
18368 int ecode2 = 0 ;
18369 PyObject * obj0 = 0 ;
18370 PyObject * obj1 = 0 ;
18371 char * kwnames[] = {
18372 (char *) "self",(char *) "skip", NULL
18373 };
18374
18375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18377 if (!SWIG_IsOK(res1)) {
18378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18379 }
18380 arg1 = reinterpret_cast< wxEvent * >(argp1);
18381 if (obj1) {
18382 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18383 if (!SWIG_IsOK(ecode2)) {
18384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18385 }
18386 arg2 = static_cast< bool >(val2);
18387 }
18388 {
18389 PyThreadState* __tstate = wxPyBeginAllowThreads();
18390 (arg1)->Skip(arg2);
18391 wxPyEndAllowThreads(__tstate);
18392 if (PyErr_Occurred()) SWIG_fail;
18393 }
18394 resultobj = SWIG_Py_Void();
18395 return resultobj;
18396 fail:
18397 return NULL;
18398 }
18399
18400
18401 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18402 PyObject *resultobj = 0;
18403 wxEvent *arg1 = (wxEvent *) 0 ;
18404 bool result;
18405 void *argp1 = 0 ;
18406 int res1 = 0 ;
18407 PyObject *swig_obj[1] ;
18408
18409 if (!args) SWIG_fail;
18410 swig_obj[0] = args;
18411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18412 if (!SWIG_IsOK(res1)) {
18413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18414 }
18415 arg1 = reinterpret_cast< wxEvent * >(argp1);
18416 {
18417 PyThreadState* __tstate = wxPyBeginAllowThreads();
18418 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18419 wxPyEndAllowThreads(__tstate);
18420 if (PyErr_Occurred()) SWIG_fail;
18421 }
18422 {
18423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18424 }
18425 return resultobj;
18426 fail:
18427 return NULL;
18428 }
18429
18430
18431 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18432 PyObject *resultobj = 0;
18433 wxEvent *arg1 = (wxEvent *) 0 ;
18434 bool result;
18435 void *argp1 = 0 ;
18436 int res1 = 0 ;
18437 PyObject *swig_obj[1] ;
18438
18439 if (!args) SWIG_fail;
18440 swig_obj[0] = args;
18441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18442 if (!SWIG_IsOK(res1)) {
18443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18444 }
18445 arg1 = reinterpret_cast< wxEvent * >(argp1);
18446 {
18447 PyThreadState* __tstate = wxPyBeginAllowThreads();
18448 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18449 wxPyEndAllowThreads(__tstate);
18450 if (PyErr_Occurred()) SWIG_fail;
18451 }
18452 {
18453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18454 }
18455 return resultobj;
18456 fail:
18457 return NULL;
18458 }
18459
18460
18461 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18462 PyObject *resultobj = 0;
18463 wxEvent *arg1 = (wxEvent *) 0 ;
18464 int result;
18465 void *argp1 = 0 ;
18466 int res1 = 0 ;
18467 PyObject *swig_obj[1] ;
18468
18469 if (!args) SWIG_fail;
18470 swig_obj[0] = args;
18471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18472 if (!SWIG_IsOK(res1)) {
18473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18474 }
18475 arg1 = reinterpret_cast< wxEvent * >(argp1);
18476 {
18477 PyThreadState* __tstate = wxPyBeginAllowThreads();
18478 result = (int)(arg1)->StopPropagation();
18479 wxPyEndAllowThreads(__tstate);
18480 if (PyErr_Occurred()) SWIG_fail;
18481 }
18482 resultobj = SWIG_From_int(static_cast< int >(result));
18483 return resultobj;
18484 fail:
18485 return NULL;
18486 }
18487
18488
18489 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18490 PyObject *resultobj = 0;
18491 wxEvent *arg1 = (wxEvent *) 0 ;
18492 int arg2 ;
18493 void *argp1 = 0 ;
18494 int res1 = 0 ;
18495 int val2 ;
18496 int ecode2 = 0 ;
18497 PyObject * obj0 = 0 ;
18498 PyObject * obj1 = 0 ;
18499 char * kwnames[] = {
18500 (char *) "self",(char *) "propagationLevel", NULL
18501 };
18502
18503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18505 if (!SWIG_IsOK(res1)) {
18506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18507 }
18508 arg1 = reinterpret_cast< wxEvent * >(argp1);
18509 ecode2 = SWIG_AsVal_int(obj1, &val2);
18510 if (!SWIG_IsOK(ecode2)) {
18511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18512 }
18513 arg2 = static_cast< int >(val2);
18514 {
18515 PyThreadState* __tstate = wxPyBeginAllowThreads();
18516 (arg1)->ResumePropagation(arg2);
18517 wxPyEndAllowThreads(__tstate);
18518 if (PyErr_Occurred()) SWIG_fail;
18519 }
18520 resultobj = SWIG_Py_Void();
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18528 PyObject *resultobj = 0;
18529 wxEvent *arg1 = (wxEvent *) 0 ;
18530 wxEvent *result = 0 ;
18531 void *argp1 = 0 ;
18532 int res1 = 0 ;
18533 PyObject *swig_obj[1] ;
18534
18535 if (!args) SWIG_fail;
18536 swig_obj[0] = args;
18537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18538 if (!SWIG_IsOK(res1)) {
18539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18540 }
18541 arg1 = reinterpret_cast< wxEvent * >(argp1);
18542 {
18543 PyThreadState* __tstate = wxPyBeginAllowThreads();
18544 result = (wxEvent *)(arg1)->Clone();
18545 wxPyEndAllowThreads(__tstate);
18546 if (PyErr_Occurred()) SWIG_fail;
18547 }
18548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18549 return resultobj;
18550 fail:
18551 return NULL;
18552 }
18553
18554
18555 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18556 PyObject *obj;
18557 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18558 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18559 return SWIG_Py_Void();
18560 }
18561
18562 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18563 PyObject *resultobj = 0;
18564 wxEvent *arg1 = 0 ;
18565 wxPropagationDisabler *result = 0 ;
18566 void *argp1 = 0 ;
18567 int res1 = 0 ;
18568 PyObject * obj0 = 0 ;
18569 char * kwnames[] = {
18570 (char *) "event", NULL
18571 };
18572
18573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18574 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18575 if (!SWIG_IsOK(res1)) {
18576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18577 }
18578 if (!argp1) {
18579 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18580 }
18581 arg1 = reinterpret_cast< wxEvent * >(argp1);
18582 {
18583 PyThreadState* __tstate = wxPyBeginAllowThreads();
18584 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18589 return resultobj;
18590 fail:
18591 return NULL;
18592 }
18593
18594
18595 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18596 PyObject *resultobj = 0;
18597 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18598 void *argp1 = 0 ;
18599 int res1 = 0 ;
18600 PyObject *swig_obj[1] ;
18601
18602 if (!args) SWIG_fail;
18603 swig_obj[0] = args;
18604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18605 if (!SWIG_IsOK(res1)) {
18606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18607 }
18608 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 delete arg1;
18612
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 resultobj = SWIG_Py_Void();
18617 return resultobj;
18618 fail:
18619 return NULL;
18620 }
18621
18622
18623 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18624 PyObject *obj;
18625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18626 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18627 return SWIG_Py_Void();
18628 }
18629
18630 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18631 return SWIG_Python_InitShadowInstance(args);
18632 }
18633
18634 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18635 PyObject *resultobj = 0;
18636 wxEvent *arg1 = 0 ;
18637 wxPropagateOnce *result = 0 ;
18638 void *argp1 = 0 ;
18639 int res1 = 0 ;
18640 PyObject * obj0 = 0 ;
18641 char * kwnames[] = {
18642 (char *) "event", NULL
18643 };
18644
18645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18646 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18647 if (!SWIG_IsOK(res1)) {
18648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18649 }
18650 if (!argp1) {
18651 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18652 }
18653 arg1 = reinterpret_cast< wxEvent * >(argp1);
18654 {
18655 PyThreadState* __tstate = wxPyBeginAllowThreads();
18656 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18657 wxPyEndAllowThreads(__tstate);
18658 if (PyErr_Occurred()) SWIG_fail;
18659 }
18660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18661 return resultobj;
18662 fail:
18663 return NULL;
18664 }
18665
18666
18667 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18668 PyObject *resultobj = 0;
18669 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18670 void *argp1 = 0 ;
18671 int res1 = 0 ;
18672 PyObject *swig_obj[1] ;
18673
18674 if (!args) SWIG_fail;
18675 swig_obj[0] = args;
18676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18677 if (!SWIG_IsOK(res1)) {
18678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18679 }
18680 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18681 {
18682 PyThreadState* __tstate = wxPyBeginAllowThreads();
18683 delete arg1;
18684
18685 wxPyEndAllowThreads(__tstate);
18686 if (PyErr_Occurred()) SWIG_fail;
18687 }
18688 resultobj = SWIG_Py_Void();
18689 return resultobj;
18690 fail:
18691 return NULL;
18692 }
18693
18694
18695 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18696 PyObject *obj;
18697 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18698 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18699 return SWIG_Py_Void();
18700 }
18701
18702 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18703 return SWIG_Python_InitShadowInstance(args);
18704 }
18705
18706 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18707 PyObject *resultobj = 0;
18708 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18709 int arg2 = (int) 0 ;
18710 wxCommandEvent *result = 0 ;
18711 int val1 ;
18712 int ecode1 = 0 ;
18713 int val2 ;
18714 int ecode2 = 0 ;
18715 PyObject * obj0 = 0 ;
18716 PyObject * obj1 = 0 ;
18717 char * kwnames[] = {
18718 (char *) "commandType",(char *) "winid", NULL
18719 };
18720
18721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18722 if (obj0) {
18723 ecode1 = SWIG_AsVal_int(obj0, &val1);
18724 if (!SWIG_IsOK(ecode1)) {
18725 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18726 }
18727 arg1 = static_cast< wxEventType >(val1);
18728 }
18729 if (obj1) {
18730 ecode2 = SWIG_AsVal_int(obj1, &val2);
18731 if (!SWIG_IsOK(ecode2)) {
18732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18733 }
18734 arg2 = static_cast< int >(val2);
18735 }
18736 {
18737 PyThreadState* __tstate = wxPyBeginAllowThreads();
18738 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18739 wxPyEndAllowThreads(__tstate);
18740 if (PyErr_Occurred()) SWIG_fail;
18741 }
18742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18743 return resultobj;
18744 fail:
18745 return NULL;
18746 }
18747
18748
18749 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18750 PyObject *resultobj = 0;
18751 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18752 int result;
18753 void *argp1 = 0 ;
18754 int res1 = 0 ;
18755 PyObject *swig_obj[1] ;
18756
18757 if (!args) SWIG_fail;
18758 swig_obj[0] = args;
18759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18760 if (!SWIG_IsOK(res1)) {
18761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18762 }
18763 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18764 {
18765 PyThreadState* __tstate = wxPyBeginAllowThreads();
18766 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18767 wxPyEndAllowThreads(__tstate);
18768 if (PyErr_Occurred()) SWIG_fail;
18769 }
18770 resultobj = SWIG_From_int(static_cast< int >(result));
18771 return resultobj;
18772 fail:
18773 return NULL;
18774 }
18775
18776
18777 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18778 PyObject *resultobj = 0;
18779 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18780 wxString *arg2 = 0 ;
18781 void *argp1 = 0 ;
18782 int res1 = 0 ;
18783 bool temp2 = false ;
18784 PyObject * obj0 = 0 ;
18785 PyObject * obj1 = 0 ;
18786 char * kwnames[] = {
18787 (char *) "self",(char *) "s", NULL
18788 };
18789
18790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18792 if (!SWIG_IsOK(res1)) {
18793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18794 }
18795 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18796 {
18797 arg2 = wxString_in_helper(obj1);
18798 if (arg2 == NULL) SWIG_fail;
18799 temp2 = true;
18800 }
18801 {
18802 PyThreadState* __tstate = wxPyBeginAllowThreads();
18803 (arg1)->SetString((wxString const &)*arg2);
18804 wxPyEndAllowThreads(__tstate);
18805 if (PyErr_Occurred()) SWIG_fail;
18806 }
18807 resultobj = SWIG_Py_Void();
18808 {
18809 if (temp2)
18810 delete arg2;
18811 }
18812 return resultobj;
18813 fail:
18814 {
18815 if (temp2)
18816 delete arg2;
18817 }
18818 return NULL;
18819 }
18820
18821
18822 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18823 PyObject *resultobj = 0;
18824 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18825 wxString result;
18826 void *argp1 = 0 ;
18827 int res1 = 0 ;
18828 PyObject *swig_obj[1] ;
18829
18830 if (!args) SWIG_fail;
18831 swig_obj[0] = args;
18832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18833 if (!SWIG_IsOK(res1)) {
18834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18835 }
18836 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18837 {
18838 PyThreadState* __tstate = wxPyBeginAllowThreads();
18839 result = ((wxCommandEvent const *)arg1)->GetString();
18840 wxPyEndAllowThreads(__tstate);
18841 if (PyErr_Occurred()) SWIG_fail;
18842 }
18843 {
18844 #if wxUSE_UNICODE
18845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18846 #else
18847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18848 #endif
18849 }
18850 return resultobj;
18851 fail:
18852 return NULL;
18853 }
18854
18855
18856 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18857 PyObject *resultobj = 0;
18858 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18859 bool result;
18860 void *argp1 = 0 ;
18861 int res1 = 0 ;
18862 PyObject *swig_obj[1] ;
18863
18864 if (!args) SWIG_fail;
18865 swig_obj[0] = args;
18866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18867 if (!SWIG_IsOK(res1)) {
18868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18869 }
18870 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18871 {
18872 PyThreadState* __tstate = wxPyBeginAllowThreads();
18873 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18874 wxPyEndAllowThreads(__tstate);
18875 if (PyErr_Occurred()) SWIG_fail;
18876 }
18877 {
18878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18879 }
18880 return resultobj;
18881 fail:
18882 return NULL;
18883 }
18884
18885
18886 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18887 PyObject *resultobj = 0;
18888 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18889 bool result;
18890 void *argp1 = 0 ;
18891 int res1 = 0 ;
18892 PyObject *swig_obj[1] ;
18893
18894 if (!args) SWIG_fail;
18895 swig_obj[0] = args;
18896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18897 if (!SWIG_IsOK(res1)) {
18898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18899 }
18900 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18901 {
18902 PyThreadState* __tstate = wxPyBeginAllowThreads();
18903 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18904 wxPyEndAllowThreads(__tstate);
18905 if (PyErr_Occurred()) SWIG_fail;
18906 }
18907 {
18908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18909 }
18910 return resultobj;
18911 fail:
18912 return NULL;
18913 }
18914
18915
18916 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18917 PyObject *resultobj = 0;
18918 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18919 long arg2 ;
18920 void *argp1 = 0 ;
18921 int res1 = 0 ;
18922 long val2 ;
18923 int ecode2 = 0 ;
18924 PyObject * obj0 = 0 ;
18925 PyObject * obj1 = 0 ;
18926 char * kwnames[] = {
18927 (char *) "self",(char *) "extraLong", NULL
18928 };
18929
18930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18932 if (!SWIG_IsOK(res1)) {
18933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18934 }
18935 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18936 ecode2 = SWIG_AsVal_long(obj1, &val2);
18937 if (!SWIG_IsOK(ecode2)) {
18938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18939 }
18940 arg2 = static_cast< long >(val2);
18941 {
18942 PyThreadState* __tstate = wxPyBeginAllowThreads();
18943 (arg1)->SetExtraLong(arg2);
18944 wxPyEndAllowThreads(__tstate);
18945 if (PyErr_Occurred()) SWIG_fail;
18946 }
18947 resultobj = SWIG_Py_Void();
18948 return resultobj;
18949 fail:
18950 return NULL;
18951 }
18952
18953
18954 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18955 PyObject *resultobj = 0;
18956 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18957 long result;
18958 void *argp1 = 0 ;
18959 int res1 = 0 ;
18960 PyObject *swig_obj[1] ;
18961
18962 if (!args) SWIG_fail;
18963 swig_obj[0] = args;
18964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18965 if (!SWIG_IsOK(res1)) {
18966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18967 }
18968 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18969 {
18970 PyThreadState* __tstate = wxPyBeginAllowThreads();
18971 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
18972 wxPyEndAllowThreads(__tstate);
18973 if (PyErr_Occurred()) SWIG_fail;
18974 }
18975 resultobj = SWIG_From_long(static_cast< long >(result));
18976 return resultobj;
18977 fail:
18978 return NULL;
18979 }
18980
18981
18982 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18983 PyObject *resultobj = 0;
18984 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18985 int arg2 ;
18986 void *argp1 = 0 ;
18987 int res1 = 0 ;
18988 int val2 ;
18989 int ecode2 = 0 ;
18990 PyObject * obj0 = 0 ;
18991 PyObject * obj1 = 0 ;
18992 char * kwnames[] = {
18993 (char *) "self",(char *) "i", NULL
18994 };
18995
18996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
18997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18998 if (!SWIG_IsOK(res1)) {
18999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19000 }
19001 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19002 ecode2 = SWIG_AsVal_int(obj1, &val2);
19003 if (!SWIG_IsOK(ecode2)) {
19004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19005 }
19006 arg2 = static_cast< int >(val2);
19007 {
19008 PyThreadState* __tstate = wxPyBeginAllowThreads();
19009 (arg1)->SetInt(arg2);
19010 wxPyEndAllowThreads(__tstate);
19011 if (PyErr_Occurred()) SWIG_fail;
19012 }
19013 resultobj = SWIG_Py_Void();
19014 return resultobj;
19015 fail:
19016 return NULL;
19017 }
19018
19019
19020 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19021 PyObject *resultobj = 0;
19022 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19023 long result;
19024 void *argp1 = 0 ;
19025 int res1 = 0 ;
19026 PyObject *swig_obj[1] ;
19027
19028 if (!args) SWIG_fail;
19029 swig_obj[0] = args;
19030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19031 if (!SWIG_IsOK(res1)) {
19032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19033 }
19034 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19035 {
19036 PyThreadState* __tstate = wxPyBeginAllowThreads();
19037 result = (long)((wxCommandEvent const *)arg1)->GetInt();
19038 wxPyEndAllowThreads(__tstate);
19039 if (PyErr_Occurred()) SWIG_fail;
19040 }
19041 resultobj = SWIG_From_long(static_cast< long >(result));
19042 return resultobj;
19043 fail:
19044 return NULL;
19045 }
19046
19047
19048 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19049 PyObject *resultobj = 0;
19050 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19051 PyObject *result = 0 ;
19052 void *argp1 = 0 ;
19053 int res1 = 0 ;
19054 PyObject *swig_obj[1] ;
19055
19056 if (!args) SWIG_fail;
19057 swig_obj[0] = args;
19058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19059 if (!SWIG_IsOK(res1)) {
19060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19061 }
19062 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19063 {
19064 PyThreadState* __tstate = wxPyBeginAllowThreads();
19065 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19066 wxPyEndAllowThreads(__tstate);
19067 if (PyErr_Occurred()) SWIG_fail;
19068 }
19069 resultobj = result;
19070 return resultobj;
19071 fail:
19072 return NULL;
19073 }
19074
19075
19076 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19077 PyObject *resultobj = 0;
19078 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19079 PyObject *arg2 = (PyObject *) 0 ;
19080 void *argp1 = 0 ;
19081 int res1 = 0 ;
19082 PyObject * obj0 = 0 ;
19083 PyObject * obj1 = 0 ;
19084 char * kwnames[] = {
19085 (char *) "self",(char *) "clientData", NULL
19086 };
19087
19088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19090 if (!SWIG_IsOK(res1)) {
19091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19092 }
19093 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19094 arg2 = obj1;
19095 {
19096 PyThreadState* __tstate = wxPyBeginAllowThreads();
19097 wxCommandEvent_SetClientData(arg1,arg2);
19098 wxPyEndAllowThreads(__tstate);
19099 if (PyErr_Occurred()) SWIG_fail;
19100 }
19101 resultobj = SWIG_Py_Void();
19102 return resultobj;
19103 fail:
19104 return NULL;
19105 }
19106
19107
19108 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19109 PyObject *resultobj = 0;
19110 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19111 wxEvent *result = 0 ;
19112 void *argp1 = 0 ;
19113 int res1 = 0 ;
19114 PyObject *swig_obj[1] ;
19115
19116 if (!args) SWIG_fail;
19117 swig_obj[0] = args;
19118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19119 if (!SWIG_IsOK(res1)) {
19120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19121 }
19122 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19123 {
19124 PyThreadState* __tstate = wxPyBeginAllowThreads();
19125 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19126 wxPyEndAllowThreads(__tstate);
19127 if (PyErr_Occurred()) SWIG_fail;
19128 }
19129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19130 return resultobj;
19131 fail:
19132 return NULL;
19133 }
19134
19135
19136 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19137 PyObject *obj;
19138 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19139 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19140 return SWIG_Py_Void();
19141 }
19142
19143 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19144 return SWIG_Python_InitShadowInstance(args);
19145 }
19146
19147 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19148 PyObject *resultobj = 0;
19149 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19150 int arg2 = (int) 0 ;
19151 wxNotifyEvent *result = 0 ;
19152 int val1 ;
19153 int ecode1 = 0 ;
19154 int val2 ;
19155 int ecode2 = 0 ;
19156 PyObject * obj0 = 0 ;
19157 PyObject * obj1 = 0 ;
19158 char * kwnames[] = {
19159 (char *) "commandType",(char *) "winid", NULL
19160 };
19161
19162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19163 if (obj0) {
19164 ecode1 = SWIG_AsVal_int(obj0, &val1);
19165 if (!SWIG_IsOK(ecode1)) {
19166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19167 }
19168 arg1 = static_cast< wxEventType >(val1);
19169 }
19170 if (obj1) {
19171 ecode2 = SWIG_AsVal_int(obj1, &val2);
19172 if (!SWIG_IsOK(ecode2)) {
19173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19174 }
19175 arg2 = static_cast< int >(val2);
19176 }
19177 {
19178 PyThreadState* __tstate = wxPyBeginAllowThreads();
19179 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19180 wxPyEndAllowThreads(__tstate);
19181 if (PyErr_Occurred()) SWIG_fail;
19182 }
19183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19184 return resultobj;
19185 fail:
19186 return NULL;
19187 }
19188
19189
19190 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19191 PyObject *resultobj = 0;
19192 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19193 void *argp1 = 0 ;
19194 int res1 = 0 ;
19195 PyObject *swig_obj[1] ;
19196
19197 if (!args) SWIG_fail;
19198 swig_obj[0] = args;
19199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19200 if (!SWIG_IsOK(res1)) {
19201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19202 }
19203 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19204 {
19205 PyThreadState* __tstate = wxPyBeginAllowThreads();
19206 (arg1)->Veto();
19207 wxPyEndAllowThreads(__tstate);
19208 if (PyErr_Occurred()) SWIG_fail;
19209 }
19210 resultobj = SWIG_Py_Void();
19211 return resultobj;
19212 fail:
19213 return NULL;
19214 }
19215
19216
19217 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19218 PyObject *resultobj = 0;
19219 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19220 void *argp1 = 0 ;
19221 int res1 = 0 ;
19222 PyObject *swig_obj[1] ;
19223
19224 if (!args) SWIG_fail;
19225 swig_obj[0] = args;
19226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19227 if (!SWIG_IsOK(res1)) {
19228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19229 }
19230 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19231 {
19232 PyThreadState* __tstate = wxPyBeginAllowThreads();
19233 (arg1)->Allow();
19234 wxPyEndAllowThreads(__tstate);
19235 if (PyErr_Occurred()) SWIG_fail;
19236 }
19237 resultobj = SWIG_Py_Void();
19238 return resultobj;
19239 fail:
19240 return NULL;
19241 }
19242
19243
19244 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19245 PyObject *resultobj = 0;
19246 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19247 bool result;
19248 void *argp1 = 0 ;
19249 int res1 = 0 ;
19250 PyObject *swig_obj[1] ;
19251
19252 if (!args) SWIG_fail;
19253 swig_obj[0] = args;
19254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19255 if (!SWIG_IsOK(res1)) {
19256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19257 }
19258 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19259 {
19260 PyThreadState* __tstate = wxPyBeginAllowThreads();
19261 result = (bool)(arg1)->IsAllowed();
19262 wxPyEndAllowThreads(__tstate);
19263 if (PyErr_Occurred()) SWIG_fail;
19264 }
19265 {
19266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19267 }
19268 return resultobj;
19269 fail:
19270 return NULL;
19271 }
19272
19273
19274 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19275 PyObject *obj;
19276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19277 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19278 return SWIG_Py_Void();
19279 }
19280
19281 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19282 return SWIG_Python_InitShadowInstance(args);
19283 }
19284
19285 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19286 PyObject *resultobj = 0;
19287 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19288 int arg2 = (int) 0 ;
19289 int arg3 = (int) 0 ;
19290 int arg4 = (int) 0 ;
19291 wxScrollEvent *result = 0 ;
19292 int val1 ;
19293 int ecode1 = 0 ;
19294 int val2 ;
19295 int ecode2 = 0 ;
19296 int val3 ;
19297 int ecode3 = 0 ;
19298 int val4 ;
19299 int ecode4 = 0 ;
19300 PyObject * obj0 = 0 ;
19301 PyObject * obj1 = 0 ;
19302 PyObject * obj2 = 0 ;
19303 PyObject * obj3 = 0 ;
19304 char * kwnames[] = {
19305 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19306 };
19307
19308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19309 if (obj0) {
19310 ecode1 = SWIG_AsVal_int(obj0, &val1);
19311 if (!SWIG_IsOK(ecode1)) {
19312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19313 }
19314 arg1 = static_cast< wxEventType >(val1);
19315 }
19316 if (obj1) {
19317 ecode2 = SWIG_AsVal_int(obj1, &val2);
19318 if (!SWIG_IsOK(ecode2)) {
19319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19320 }
19321 arg2 = static_cast< int >(val2);
19322 }
19323 if (obj2) {
19324 ecode3 = SWIG_AsVal_int(obj2, &val3);
19325 if (!SWIG_IsOK(ecode3)) {
19326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19327 }
19328 arg3 = static_cast< int >(val3);
19329 }
19330 if (obj3) {
19331 ecode4 = SWIG_AsVal_int(obj3, &val4);
19332 if (!SWIG_IsOK(ecode4)) {
19333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19334 }
19335 arg4 = static_cast< int >(val4);
19336 }
19337 {
19338 PyThreadState* __tstate = wxPyBeginAllowThreads();
19339 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19340 wxPyEndAllowThreads(__tstate);
19341 if (PyErr_Occurred()) SWIG_fail;
19342 }
19343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19344 return resultobj;
19345 fail:
19346 return NULL;
19347 }
19348
19349
19350 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19351 PyObject *resultobj = 0;
19352 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19353 int result;
19354 void *argp1 = 0 ;
19355 int res1 = 0 ;
19356 PyObject *swig_obj[1] ;
19357
19358 if (!args) SWIG_fail;
19359 swig_obj[0] = args;
19360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19361 if (!SWIG_IsOK(res1)) {
19362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19363 }
19364 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19365 {
19366 PyThreadState* __tstate = wxPyBeginAllowThreads();
19367 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19368 wxPyEndAllowThreads(__tstate);
19369 if (PyErr_Occurred()) SWIG_fail;
19370 }
19371 resultobj = SWIG_From_int(static_cast< int >(result));
19372 return resultobj;
19373 fail:
19374 return NULL;
19375 }
19376
19377
19378 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19379 PyObject *resultobj = 0;
19380 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19381 int result;
19382 void *argp1 = 0 ;
19383 int res1 = 0 ;
19384 PyObject *swig_obj[1] ;
19385
19386 if (!args) SWIG_fail;
19387 swig_obj[0] = args;
19388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19389 if (!SWIG_IsOK(res1)) {
19390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19391 }
19392 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19393 {
19394 PyThreadState* __tstate = wxPyBeginAllowThreads();
19395 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19396 wxPyEndAllowThreads(__tstate);
19397 if (PyErr_Occurred()) SWIG_fail;
19398 }
19399 resultobj = SWIG_From_int(static_cast< int >(result));
19400 return resultobj;
19401 fail:
19402 return NULL;
19403 }
19404
19405
19406 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19407 PyObject *resultobj = 0;
19408 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19409 int arg2 ;
19410 void *argp1 = 0 ;
19411 int res1 = 0 ;
19412 int val2 ;
19413 int ecode2 = 0 ;
19414 PyObject * obj0 = 0 ;
19415 PyObject * obj1 = 0 ;
19416 char * kwnames[] = {
19417 (char *) "self",(char *) "orient", NULL
19418 };
19419
19420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19422 if (!SWIG_IsOK(res1)) {
19423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19424 }
19425 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19426 ecode2 = SWIG_AsVal_int(obj1, &val2);
19427 if (!SWIG_IsOK(ecode2)) {
19428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19429 }
19430 arg2 = static_cast< int >(val2);
19431 {
19432 PyThreadState* __tstate = wxPyBeginAllowThreads();
19433 (arg1)->SetOrientation(arg2);
19434 wxPyEndAllowThreads(__tstate);
19435 if (PyErr_Occurred()) SWIG_fail;
19436 }
19437 resultobj = SWIG_Py_Void();
19438 return resultobj;
19439 fail:
19440 return NULL;
19441 }
19442
19443
19444 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19445 PyObject *resultobj = 0;
19446 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19447 int arg2 ;
19448 void *argp1 = 0 ;
19449 int res1 = 0 ;
19450 int val2 ;
19451 int ecode2 = 0 ;
19452 PyObject * obj0 = 0 ;
19453 PyObject * obj1 = 0 ;
19454 char * kwnames[] = {
19455 (char *) "self",(char *) "pos", NULL
19456 };
19457
19458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19460 if (!SWIG_IsOK(res1)) {
19461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19462 }
19463 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19464 ecode2 = SWIG_AsVal_int(obj1, &val2);
19465 if (!SWIG_IsOK(ecode2)) {
19466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19467 }
19468 arg2 = static_cast< int >(val2);
19469 {
19470 PyThreadState* __tstate = wxPyBeginAllowThreads();
19471 (arg1)->SetPosition(arg2);
19472 wxPyEndAllowThreads(__tstate);
19473 if (PyErr_Occurred()) SWIG_fail;
19474 }
19475 resultobj = SWIG_Py_Void();
19476 return resultobj;
19477 fail:
19478 return NULL;
19479 }
19480
19481
19482 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19483 PyObject *obj;
19484 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19485 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19486 return SWIG_Py_Void();
19487 }
19488
19489 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19490 return SWIG_Python_InitShadowInstance(args);
19491 }
19492
19493 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19494 PyObject *resultobj = 0;
19495 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19496 int arg2 = (int) 0 ;
19497 int arg3 = (int) 0 ;
19498 wxScrollWinEvent *result = 0 ;
19499 int val1 ;
19500 int ecode1 = 0 ;
19501 int val2 ;
19502 int ecode2 = 0 ;
19503 int val3 ;
19504 int ecode3 = 0 ;
19505 PyObject * obj0 = 0 ;
19506 PyObject * obj1 = 0 ;
19507 PyObject * obj2 = 0 ;
19508 char * kwnames[] = {
19509 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19510 };
19511
19512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19513 if (obj0) {
19514 ecode1 = SWIG_AsVal_int(obj0, &val1);
19515 if (!SWIG_IsOK(ecode1)) {
19516 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19517 }
19518 arg1 = static_cast< wxEventType >(val1);
19519 }
19520 if (obj1) {
19521 ecode2 = SWIG_AsVal_int(obj1, &val2);
19522 if (!SWIG_IsOK(ecode2)) {
19523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19524 }
19525 arg2 = static_cast< int >(val2);
19526 }
19527 if (obj2) {
19528 ecode3 = SWIG_AsVal_int(obj2, &val3);
19529 if (!SWIG_IsOK(ecode3)) {
19530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19531 }
19532 arg3 = static_cast< int >(val3);
19533 }
19534 {
19535 PyThreadState* __tstate = wxPyBeginAllowThreads();
19536 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19537 wxPyEndAllowThreads(__tstate);
19538 if (PyErr_Occurred()) SWIG_fail;
19539 }
19540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19541 return resultobj;
19542 fail:
19543 return NULL;
19544 }
19545
19546
19547 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19548 PyObject *resultobj = 0;
19549 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19550 int result;
19551 void *argp1 = 0 ;
19552 int res1 = 0 ;
19553 PyObject *swig_obj[1] ;
19554
19555 if (!args) SWIG_fail;
19556 swig_obj[0] = args;
19557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19558 if (!SWIG_IsOK(res1)) {
19559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19560 }
19561 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19562 {
19563 PyThreadState* __tstate = wxPyBeginAllowThreads();
19564 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19565 wxPyEndAllowThreads(__tstate);
19566 if (PyErr_Occurred()) SWIG_fail;
19567 }
19568 resultobj = SWIG_From_int(static_cast< int >(result));
19569 return resultobj;
19570 fail:
19571 return NULL;
19572 }
19573
19574
19575 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19576 PyObject *resultobj = 0;
19577 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19578 int result;
19579 void *argp1 = 0 ;
19580 int res1 = 0 ;
19581 PyObject *swig_obj[1] ;
19582
19583 if (!args) SWIG_fail;
19584 swig_obj[0] = args;
19585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19586 if (!SWIG_IsOK(res1)) {
19587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19588 }
19589 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19590 {
19591 PyThreadState* __tstate = wxPyBeginAllowThreads();
19592 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19593 wxPyEndAllowThreads(__tstate);
19594 if (PyErr_Occurred()) SWIG_fail;
19595 }
19596 resultobj = SWIG_From_int(static_cast< int >(result));
19597 return resultobj;
19598 fail:
19599 return NULL;
19600 }
19601
19602
19603 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19604 PyObject *resultobj = 0;
19605 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19606 int arg2 ;
19607 void *argp1 = 0 ;
19608 int res1 = 0 ;
19609 int val2 ;
19610 int ecode2 = 0 ;
19611 PyObject * obj0 = 0 ;
19612 PyObject * obj1 = 0 ;
19613 char * kwnames[] = {
19614 (char *) "self",(char *) "orient", NULL
19615 };
19616
19617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19619 if (!SWIG_IsOK(res1)) {
19620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19621 }
19622 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19623 ecode2 = SWIG_AsVal_int(obj1, &val2);
19624 if (!SWIG_IsOK(ecode2)) {
19625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19626 }
19627 arg2 = static_cast< int >(val2);
19628 {
19629 PyThreadState* __tstate = wxPyBeginAllowThreads();
19630 (arg1)->SetOrientation(arg2);
19631 wxPyEndAllowThreads(__tstate);
19632 if (PyErr_Occurred()) SWIG_fail;
19633 }
19634 resultobj = SWIG_Py_Void();
19635 return resultobj;
19636 fail:
19637 return NULL;
19638 }
19639
19640
19641 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19642 PyObject *resultobj = 0;
19643 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19644 int arg2 ;
19645 void *argp1 = 0 ;
19646 int res1 = 0 ;
19647 int val2 ;
19648 int ecode2 = 0 ;
19649 PyObject * obj0 = 0 ;
19650 PyObject * obj1 = 0 ;
19651 char * kwnames[] = {
19652 (char *) "self",(char *) "pos", NULL
19653 };
19654
19655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19657 if (!SWIG_IsOK(res1)) {
19658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19659 }
19660 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19661 ecode2 = SWIG_AsVal_int(obj1, &val2);
19662 if (!SWIG_IsOK(ecode2)) {
19663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19664 }
19665 arg2 = static_cast< int >(val2);
19666 {
19667 PyThreadState* __tstate = wxPyBeginAllowThreads();
19668 (arg1)->SetPosition(arg2);
19669 wxPyEndAllowThreads(__tstate);
19670 if (PyErr_Occurred()) SWIG_fail;
19671 }
19672 resultobj = SWIG_Py_Void();
19673 return resultobj;
19674 fail:
19675 return NULL;
19676 }
19677
19678
19679 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19680 PyObject *obj;
19681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19682 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19683 return SWIG_Py_Void();
19684 }
19685
19686 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19687 return SWIG_Python_InitShadowInstance(args);
19688 }
19689
19690 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19691 PyObject *resultobj = 0;
19692 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19693 wxMouseEvent *result = 0 ;
19694 int val1 ;
19695 int ecode1 = 0 ;
19696 PyObject * obj0 = 0 ;
19697 char * kwnames[] = {
19698 (char *) "mouseType", NULL
19699 };
19700
19701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19702 if (obj0) {
19703 ecode1 = SWIG_AsVal_int(obj0, &val1);
19704 if (!SWIG_IsOK(ecode1)) {
19705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19706 }
19707 arg1 = static_cast< wxEventType >(val1);
19708 }
19709 {
19710 PyThreadState* __tstate = wxPyBeginAllowThreads();
19711 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19712 wxPyEndAllowThreads(__tstate);
19713 if (PyErr_Occurred()) SWIG_fail;
19714 }
19715 {
19716 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19717 }
19718 return resultobj;
19719 fail:
19720 return NULL;
19721 }
19722
19723
19724 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19725 PyObject *resultobj = 0;
19726 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19727 bool result;
19728 void *argp1 = 0 ;
19729 int res1 = 0 ;
19730 PyObject *swig_obj[1] ;
19731
19732 if (!args) SWIG_fail;
19733 swig_obj[0] = args;
19734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19735 if (!SWIG_IsOK(res1)) {
19736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19737 }
19738 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19739 {
19740 PyThreadState* __tstate = wxPyBeginAllowThreads();
19741 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19742 wxPyEndAllowThreads(__tstate);
19743 if (PyErr_Occurred()) SWIG_fail;
19744 }
19745 {
19746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19747 }
19748 return resultobj;
19749 fail:
19750 return NULL;
19751 }
19752
19753
19754 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19755 PyObject *resultobj = 0;
19756 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19757 int arg2 = (int) wxMOUSE_BTN_ANY ;
19758 bool result;
19759 void *argp1 = 0 ;
19760 int res1 = 0 ;
19761 int val2 ;
19762 int ecode2 = 0 ;
19763 PyObject * obj0 = 0 ;
19764 PyObject * obj1 = 0 ;
19765 char * kwnames[] = {
19766 (char *) "self",(char *) "but", NULL
19767 };
19768
19769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19771 if (!SWIG_IsOK(res1)) {
19772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19773 }
19774 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19775 if (obj1) {
19776 ecode2 = SWIG_AsVal_int(obj1, &val2);
19777 if (!SWIG_IsOK(ecode2)) {
19778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19779 }
19780 arg2 = static_cast< int >(val2);
19781 }
19782 {
19783 PyThreadState* __tstate = wxPyBeginAllowThreads();
19784 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19785 wxPyEndAllowThreads(__tstate);
19786 if (PyErr_Occurred()) SWIG_fail;
19787 }
19788 {
19789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19790 }
19791 return resultobj;
19792 fail:
19793 return NULL;
19794 }
19795
19796
19797 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19798 PyObject *resultobj = 0;
19799 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19800 int arg2 = (int) wxMOUSE_BTN_ANY ;
19801 bool result;
19802 void *argp1 = 0 ;
19803 int res1 = 0 ;
19804 int val2 ;
19805 int ecode2 = 0 ;
19806 PyObject * obj0 = 0 ;
19807 PyObject * obj1 = 0 ;
19808 char * kwnames[] = {
19809 (char *) "self",(char *) "but", NULL
19810 };
19811
19812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19814 if (!SWIG_IsOK(res1)) {
19815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19816 }
19817 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19818 if (obj1) {
19819 ecode2 = SWIG_AsVal_int(obj1, &val2);
19820 if (!SWIG_IsOK(ecode2)) {
19821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19822 }
19823 arg2 = static_cast< int >(val2);
19824 }
19825 {
19826 PyThreadState* __tstate = wxPyBeginAllowThreads();
19827 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19828 wxPyEndAllowThreads(__tstate);
19829 if (PyErr_Occurred()) SWIG_fail;
19830 }
19831 {
19832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19833 }
19834 return resultobj;
19835 fail:
19836 return NULL;
19837 }
19838
19839
19840 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19841 PyObject *resultobj = 0;
19842 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19843 int arg2 = (int) wxMOUSE_BTN_ANY ;
19844 bool result;
19845 void *argp1 = 0 ;
19846 int res1 = 0 ;
19847 int val2 ;
19848 int ecode2 = 0 ;
19849 PyObject * obj0 = 0 ;
19850 PyObject * obj1 = 0 ;
19851 char * kwnames[] = {
19852 (char *) "self",(char *) "but", NULL
19853 };
19854
19855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19857 if (!SWIG_IsOK(res1)) {
19858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19859 }
19860 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19861 if (obj1) {
19862 ecode2 = SWIG_AsVal_int(obj1, &val2);
19863 if (!SWIG_IsOK(ecode2)) {
19864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19865 }
19866 arg2 = static_cast< int >(val2);
19867 }
19868 {
19869 PyThreadState* __tstate = wxPyBeginAllowThreads();
19870 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19871 wxPyEndAllowThreads(__tstate);
19872 if (PyErr_Occurred()) SWIG_fail;
19873 }
19874 {
19875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19876 }
19877 return resultobj;
19878 fail:
19879 return NULL;
19880 }
19881
19882
19883 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19884 PyObject *resultobj = 0;
19885 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19886 int arg2 ;
19887 bool result;
19888 void *argp1 = 0 ;
19889 int res1 = 0 ;
19890 int val2 ;
19891 int ecode2 = 0 ;
19892 PyObject * obj0 = 0 ;
19893 PyObject * obj1 = 0 ;
19894 char * kwnames[] = {
19895 (char *) "self",(char *) "button", NULL
19896 };
19897
19898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19900 if (!SWIG_IsOK(res1)) {
19901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19902 }
19903 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19904 ecode2 = SWIG_AsVal_int(obj1, &val2);
19905 if (!SWIG_IsOK(ecode2)) {
19906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19907 }
19908 arg2 = static_cast< int >(val2);
19909 {
19910 PyThreadState* __tstate = wxPyBeginAllowThreads();
19911 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19912 wxPyEndAllowThreads(__tstate);
19913 if (PyErr_Occurred()) SWIG_fail;
19914 }
19915 {
19916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19917 }
19918 return resultobj;
19919 fail:
19920 return NULL;
19921 }
19922
19923
19924 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19925 PyObject *resultobj = 0;
19926 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19927 int arg2 ;
19928 bool result;
19929 void *argp1 = 0 ;
19930 int res1 = 0 ;
19931 int val2 ;
19932 int ecode2 = 0 ;
19933 PyObject * obj0 = 0 ;
19934 PyObject * obj1 = 0 ;
19935 char * kwnames[] = {
19936 (char *) "self",(char *) "but", NULL
19937 };
19938
19939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
19940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19941 if (!SWIG_IsOK(res1)) {
19942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19943 }
19944 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19945 ecode2 = SWIG_AsVal_int(obj1, &val2);
19946 if (!SWIG_IsOK(ecode2)) {
19947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
19948 }
19949 arg2 = static_cast< int >(val2);
19950 {
19951 PyThreadState* __tstate = wxPyBeginAllowThreads();
19952 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
19953 wxPyEndAllowThreads(__tstate);
19954 if (PyErr_Occurred()) SWIG_fail;
19955 }
19956 {
19957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19958 }
19959 return resultobj;
19960 fail:
19961 return NULL;
19962 }
19963
19964
19965 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19966 PyObject *resultobj = 0;
19967 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19968 int result;
19969 void *argp1 = 0 ;
19970 int res1 = 0 ;
19971 PyObject *swig_obj[1] ;
19972
19973 if (!args) SWIG_fail;
19974 swig_obj[0] = args;
19975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19976 if (!SWIG_IsOK(res1)) {
19977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19978 }
19979 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19980 {
19981 PyThreadState* __tstate = wxPyBeginAllowThreads();
19982 result = (int)((wxMouseEvent const *)arg1)->GetButton();
19983 wxPyEndAllowThreads(__tstate);
19984 if (PyErr_Occurred()) SWIG_fail;
19985 }
19986 resultobj = SWIG_From_int(static_cast< int >(result));
19987 return resultobj;
19988 fail:
19989 return NULL;
19990 }
19991
19992
19993 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19994 PyObject *resultobj = 0;
19995 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19996 bool result;
19997 void *argp1 = 0 ;
19998 int res1 = 0 ;
19999 PyObject *swig_obj[1] ;
20000
20001 if (!args) SWIG_fail;
20002 swig_obj[0] = args;
20003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20004 if (!SWIG_IsOK(res1)) {
20005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20006 }
20007 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20008 {
20009 PyThreadState* __tstate = wxPyBeginAllowThreads();
20010 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20011 wxPyEndAllowThreads(__tstate);
20012 if (PyErr_Occurred()) SWIG_fail;
20013 }
20014 {
20015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20016 }
20017 return resultobj;
20018 fail:
20019 return NULL;
20020 }
20021
20022
20023 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20024 PyObject *resultobj = 0;
20025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20026 bool result;
20027 void *argp1 = 0 ;
20028 int res1 = 0 ;
20029 PyObject *swig_obj[1] ;
20030
20031 if (!args) SWIG_fail;
20032 swig_obj[0] = args;
20033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20034 if (!SWIG_IsOK(res1)) {
20035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20036 }
20037 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20038 {
20039 PyThreadState* __tstate = wxPyBeginAllowThreads();
20040 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20041 wxPyEndAllowThreads(__tstate);
20042 if (PyErr_Occurred()) SWIG_fail;
20043 }
20044 {
20045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20046 }
20047 return resultobj;
20048 fail:
20049 return NULL;
20050 }
20051
20052
20053 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20054 PyObject *resultobj = 0;
20055 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20056 bool result;
20057 void *argp1 = 0 ;
20058 int res1 = 0 ;
20059 PyObject *swig_obj[1] ;
20060
20061 if (!args) SWIG_fail;
20062 swig_obj[0] = args;
20063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20064 if (!SWIG_IsOK(res1)) {
20065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20066 }
20067 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20068 {
20069 PyThreadState* __tstate = wxPyBeginAllowThreads();
20070 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20071 wxPyEndAllowThreads(__tstate);
20072 if (PyErr_Occurred()) SWIG_fail;
20073 }
20074 {
20075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20076 }
20077 return resultobj;
20078 fail:
20079 return NULL;
20080 }
20081
20082
20083 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20084 PyObject *resultobj = 0;
20085 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20086 bool result;
20087 void *argp1 = 0 ;
20088 int res1 = 0 ;
20089 PyObject *swig_obj[1] ;
20090
20091 if (!args) SWIG_fail;
20092 swig_obj[0] = args;
20093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20094 if (!SWIG_IsOK(res1)) {
20095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20096 }
20097 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20098 {
20099 PyThreadState* __tstate = wxPyBeginAllowThreads();
20100 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20101 wxPyEndAllowThreads(__tstate);
20102 if (PyErr_Occurred()) SWIG_fail;
20103 }
20104 {
20105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20106 }
20107 return resultobj;
20108 fail:
20109 return NULL;
20110 }
20111
20112
20113 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20114 PyObject *resultobj = 0;
20115 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20116 bool result;
20117 void *argp1 = 0 ;
20118 int res1 = 0 ;
20119 PyObject *swig_obj[1] ;
20120
20121 if (!args) SWIG_fail;
20122 swig_obj[0] = args;
20123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20124 if (!SWIG_IsOK(res1)) {
20125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20126 }
20127 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20128 {
20129 PyThreadState* __tstate = wxPyBeginAllowThreads();
20130 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20131 wxPyEndAllowThreads(__tstate);
20132 if (PyErr_Occurred()) SWIG_fail;
20133 }
20134 {
20135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20136 }
20137 return resultobj;
20138 fail:
20139 return NULL;
20140 }
20141
20142
20143 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20144 PyObject *resultobj = 0;
20145 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20146 bool result;
20147 void *argp1 = 0 ;
20148 int res1 = 0 ;
20149 PyObject *swig_obj[1] ;
20150
20151 if (!args) SWIG_fail;
20152 swig_obj[0] = args;
20153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20154 if (!SWIG_IsOK(res1)) {
20155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20156 }
20157 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20158 {
20159 PyThreadState* __tstate = wxPyBeginAllowThreads();
20160 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20161 wxPyEndAllowThreads(__tstate);
20162 if (PyErr_Occurred()) SWIG_fail;
20163 }
20164 {
20165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20166 }
20167 return resultobj;
20168 fail:
20169 return NULL;
20170 }
20171
20172
20173 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20174 PyObject *resultobj = 0;
20175 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20176 bool result;
20177 void *argp1 = 0 ;
20178 int res1 = 0 ;
20179 PyObject *swig_obj[1] ;
20180
20181 if (!args) SWIG_fail;
20182 swig_obj[0] = args;
20183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20184 if (!SWIG_IsOK(res1)) {
20185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20186 }
20187 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20188 {
20189 PyThreadState* __tstate = wxPyBeginAllowThreads();
20190 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20191 wxPyEndAllowThreads(__tstate);
20192 if (PyErr_Occurred()) SWIG_fail;
20193 }
20194 {
20195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20196 }
20197 return resultobj;
20198 fail:
20199 return NULL;
20200 }
20201
20202
20203 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20204 PyObject *resultobj = 0;
20205 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20206 bool result;
20207 void *argp1 = 0 ;
20208 int res1 = 0 ;
20209 PyObject *swig_obj[1] ;
20210
20211 if (!args) SWIG_fail;
20212 swig_obj[0] = args;
20213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20214 if (!SWIG_IsOK(res1)) {
20215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20216 }
20217 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20218 {
20219 PyThreadState* __tstate = wxPyBeginAllowThreads();
20220 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20221 wxPyEndAllowThreads(__tstate);
20222 if (PyErr_Occurred()) SWIG_fail;
20223 }
20224 {
20225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20226 }
20227 return resultobj;
20228 fail:
20229 return NULL;
20230 }
20231
20232
20233 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20234 PyObject *resultobj = 0;
20235 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20236 bool result;
20237 void *argp1 = 0 ;
20238 int res1 = 0 ;
20239 PyObject *swig_obj[1] ;
20240
20241 if (!args) SWIG_fail;
20242 swig_obj[0] = args;
20243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20244 if (!SWIG_IsOK(res1)) {
20245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20246 }
20247 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20248 {
20249 PyThreadState* __tstate = wxPyBeginAllowThreads();
20250 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20251 wxPyEndAllowThreads(__tstate);
20252 if (PyErr_Occurred()) SWIG_fail;
20253 }
20254 {
20255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20256 }
20257 return resultobj;
20258 fail:
20259 return NULL;
20260 }
20261
20262
20263 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20264 PyObject *resultobj = 0;
20265 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20266 bool result;
20267 void *argp1 = 0 ;
20268 int res1 = 0 ;
20269 PyObject *swig_obj[1] ;
20270
20271 if (!args) SWIG_fail;
20272 swig_obj[0] = args;
20273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20274 if (!SWIG_IsOK(res1)) {
20275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20276 }
20277 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20278 {
20279 PyThreadState* __tstate = wxPyBeginAllowThreads();
20280 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20281 wxPyEndAllowThreads(__tstate);
20282 if (PyErr_Occurred()) SWIG_fail;
20283 }
20284 {
20285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20286 }
20287 return resultobj;
20288 fail:
20289 return NULL;
20290 }
20291
20292
20293 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20294 PyObject *resultobj = 0;
20295 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20296 bool result;
20297 void *argp1 = 0 ;
20298 int res1 = 0 ;
20299 PyObject *swig_obj[1] ;
20300
20301 if (!args) SWIG_fail;
20302 swig_obj[0] = args;
20303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20304 if (!SWIG_IsOK(res1)) {
20305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20306 }
20307 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20308 {
20309 PyThreadState* __tstate = wxPyBeginAllowThreads();
20310 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20311 wxPyEndAllowThreads(__tstate);
20312 if (PyErr_Occurred()) SWIG_fail;
20313 }
20314 {
20315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20316 }
20317 return resultobj;
20318 fail:
20319 return NULL;
20320 }
20321
20322
20323 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20324 PyObject *resultobj = 0;
20325 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20326 bool result;
20327 void *argp1 = 0 ;
20328 int res1 = 0 ;
20329 PyObject *swig_obj[1] ;
20330
20331 if (!args) SWIG_fail;
20332 swig_obj[0] = args;
20333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20334 if (!SWIG_IsOK(res1)) {
20335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20336 }
20337 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20338 {
20339 PyThreadState* __tstate = wxPyBeginAllowThreads();
20340 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20341 wxPyEndAllowThreads(__tstate);
20342 if (PyErr_Occurred()) SWIG_fail;
20343 }
20344 {
20345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20346 }
20347 return resultobj;
20348 fail:
20349 return NULL;
20350 }
20351
20352
20353 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20354 PyObject *resultobj = 0;
20355 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20356 bool result;
20357 void *argp1 = 0 ;
20358 int res1 = 0 ;
20359 PyObject *swig_obj[1] ;
20360
20361 if (!args) SWIG_fail;
20362 swig_obj[0] = args;
20363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20364 if (!SWIG_IsOK(res1)) {
20365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20366 }
20367 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20368 {
20369 PyThreadState* __tstate = wxPyBeginAllowThreads();
20370 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20371 wxPyEndAllowThreads(__tstate);
20372 if (PyErr_Occurred()) SWIG_fail;
20373 }
20374 {
20375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20376 }
20377 return resultobj;
20378 fail:
20379 return NULL;
20380 }
20381
20382
20383 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20384 PyObject *resultobj = 0;
20385 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20386 bool result;
20387 void *argp1 = 0 ;
20388 int res1 = 0 ;
20389 PyObject *swig_obj[1] ;
20390
20391 if (!args) SWIG_fail;
20392 swig_obj[0] = args;
20393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20394 if (!SWIG_IsOK(res1)) {
20395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20396 }
20397 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20398 {
20399 PyThreadState* __tstate = wxPyBeginAllowThreads();
20400 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20401 wxPyEndAllowThreads(__tstate);
20402 if (PyErr_Occurred()) SWIG_fail;
20403 }
20404 {
20405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20406 }
20407 return resultobj;
20408 fail:
20409 return NULL;
20410 }
20411
20412
20413 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20414 PyObject *resultobj = 0;
20415 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20416 bool result;
20417 void *argp1 = 0 ;
20418 int res1 = 0 ;
20419 PyObject *swig_obj[1] ;
20420
20421 if (!args) SWIG_fail;
20422 swig_obj[0] = args;
20423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20424 if (!SWIG_IsOK(res1)) {
20425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20426 }
20427 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20428 {
20429 PyThreadState* __tstate = wxPyBeginAllowThreads();
20430 result = (bool)(arg1)->LeftIsDown();
20431 wxPyEndAllowThreads(__tstate);
20432 if (PyErr_Occurred()) SWIG_fail;
20433 }
20434 {
20435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20436 }
20437 return resultobj;
20438 fail:
20439 return NULL;
20440 }
20441
20442
20443 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20444 PyObject *resultobj = 0;
20445 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20446 bool result;
20447 void *argp1 = 0 ;
20448 int res1 = 0 ;
20449 PyObject *swig_obj[1] ;
20450
20451 if (!args) SWIG_fail;
20452 swig_obj[0] = args;
20453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20454 if (!SWIG_IsOK(res1)) {
20455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20456 }
20457 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20458 {
20459 PyThreadState* __tstate = wxPyBeginAllowThreads();
20460 result = (bool)(arg1)->MiddleIsDown();
20461 wxPyEndAllowThreads(__tstate);
20462 if (PyErr_Occurred()) SWIG_fail;
20463 }
20464 {
20465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20466 }
20467 return resultobj;
20468 fail:
20469 return NULL;
20470 }
20471
20472
20473 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20474 PyObject *resultobj = 0;
20475 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20476 bool result;
20477 void *argp1 = 0 ;
20478 int res1 = 0 ;
20479 PyObject *swig_obj[1] ;
20480
20481 if (!args) SWIG_fail;
20482 swig_obj[0] = args;
20483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20484 if (!SWIG_IsOK(res1)) {
20485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20486 }
20487 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20488 {
20489 PyThreadState* __tstate = wxPyBeginAllowThreads();
20490 result = (bool)(arg1)->RightIsDown();
20491 wxPyEndAllowThreads(__tstate);
20492 if (PyErr_Occurred()) SWIG_fail;
20493 }
20494 {
20495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20496 }
20497 return resultobj;
20498 fail:
20499 return NULL;
20500 }
20501
20502
20503 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20504 PyObject *resultobj = 0;
20505 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20506 bool result;
20507 void *argp1 = 0 ;
20508 int res1 = 0 ;
20509 PyObject *swig_obj[1] ;
20510
20511 if (!args) SWIG_fail;
20512 swig_obj[0] = args;
20513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20514 if (!SWIG_IsOK(res1)) {
20515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20516 }
20517 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20518 {
20519 PyThreadState* __tstate = wxPyBeginAllowThreads();
20520 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20521 wxPyEndAllowThreads(__tstate);
20522 if (PyErr_Occurred()) SWIG_fail;
20523 }
20524 {
20525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20526 }
20527 return resultobj;
20528 fail:
20529 return NULL;
20530 }
20531
20532
20533 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20534 PyObject *resultobj = 0;
20535 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20536 bool result;
20537 void *argp1 = 0 ;
20538 int res1 = 0 ;
20539 PyObject *swig_obj[1] ;
20540
20541 if (!args) SWIG_fail;
20542 swig_obj[0] = args;
20543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20544 if (!SWIG_IsOK(res1)) {
20545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20546 }
20547 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20548 {
20549 PyThreadState* __tstate = wxPyBeginAllowThreads();
20550 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20551 wxPyEndAllowThreads(__tstate);
20552 if (PyErr_Occurred()) SWIG_fail;
20553 }
20554 {
20555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20556 }
20557 return resultobj;
20558 fail:
20559 return NULL;
20560 }
20561
20562
20563 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20564 PyObject *resultobj = 0;
20565 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20566 bool result;
20567 void *argp1 = 0 ;
20568 int res1 = 0 ;
20569 PyObject *swig_obj[1] ;
20570
20571 if (!args) SWIG_fail;
20572 swig_obj[0] = args;
20573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20574 if (!SWIG_IsOK(res1)) {
20575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20576 }
20577 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20578 {
20579 PyThreadState* __tstate = wxPyBeginAllowThreads();
20580 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20581 wxPyEndAllowThreads(__tstate);
20582 if (PyErr_Occurred()) SWIG_fail;
20583 }
20584 {
20585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20586 }
20587 return resultobj;
20588 fail:
20589 return NULL;
20590 }
20591
20592
20593 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20594 PyObject *resultobj = 0;
20595 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20596 bool result;
20597 void *argp1 = 0 ;
20598 int res1 = 0 ;
20599 PyObject *swig_obj[1] ;
20600
20601 if (!args) SWIG_fail;
20602 swig_obj[0] = args;
20603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20604 if (!SWIG_IsOK(res1)) {
20605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20606 }
20607 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20608 {
20609 PyThreadState* __tstate = wxPyBeginAllowThreads();
20610 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20611 wxPyEndAllowThreads(__tstate);
20612 if (PyErr_Occurred()) SWIG_fail;
20613 }
20614 {
20615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20616 }
20617 return resultobj;
20618 fail:
20619 return NULL;
20620 }
20621
20622
20623 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20624 PyObject *resultobj = 0;
20625 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20626 wxPoint result;
20627 void *argp1 = 0 ;
20628 int res1 = 0 ;
20629 PyObject *swig_obj[1] ;
20630
20631 if (!args) SWIG_fail;
20632 swig_obj[0] = args;
20633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20634 if (!SWIG_IsOK(res1)) {
20635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20636 }
20637 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20638 {
20639 PyThreadState* __tstate = wxPyBeginAllowThreads();
20640 result = (arg1)->GetPosition();
20641 wxPyEndAllowThreads(__tstate);
20642 if (PyErr_Occurred()) SWIG_fail;
20643 }
20644 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20645 return resultobj;
20646 fail:
20647 return NULL;
20648 }
20649
20650
20651 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20652 PyObject *resultobj = 0;
20653 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20654 long *arg2 = (long *) 0 ;
20655 long *arg3 = (long *) 0 ;
20656 void *argp1 = 0 ;
20657 int res1 = 0 ;
20658 long temp2 ;
20659 int res2 = SWIG_TMPOBJ ;
20660 long temp3 ;
20661 int res3 = SWIG_TMPOBJ ;
20662 PyObject *swig_obj[1] ;
20663
20664 arg2 = &temp2;
20665 arg3 = &temp3;
20666 if (!args) SWIG_fail;
20667 swig_obj[0] = args;
20668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20669 if (!SWIG_IsOK(res1)) {
20670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20671 }
20672 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20673 {
20674 PyThreadState* __tstate = wxPyBeginAllowThreads();
20675 (arg1)->GetPosition(arg2,arg3);
20676 wxPyEndAllowThreads(__tstate);
20677 if (PyErr_Occurred()) SWIG_fail;
20678 }
20679 resultobj = SWIG_Py_Void();
20680 if (SWIG_IsTmpObj(res2)) {
20681 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20682 } else {
20683 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20684 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20685 }
20686 if (SWIG_IsTmpObj(res3)) {
20687 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20688 } else {
20689 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20690 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20691 }
20692 return resultobj;
20693 fail:
20694 return NULL;
20695 }
20696
20697
20698 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20699 PyObject *resultobj = 0;
20700 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20701 wxDC *arg2 = 0 ;
20702 wxPoint result;
20703 void *argp1 = 0 ;
20704 int res1 = 0 ;
20705 void *argp2 = 0 ;
20706 int res2 = 0 ;
20707 PyObject * obj0 = 0 ;
20708 PyObject * obj1 = 0 ;
20709 char * kwnames[] = {
20710 (char *) "self",(char *) "dc", NULL
20711 };
20712
20713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20715 if (!SWIG_IsOK(res1)) {
20716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20717 }
20718 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20719 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20720 if (!SWIG_IsOK(res2)) {
20721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20722 }
20723 if (!argp2) {
20724 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20725 }
20726 arg2 = reinterpret_cast< wxDC * >(argp2);
20727 {
20728 PyThreadState* __tstate = wxPyBeginAllowThreads();
20729 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20730 wxPyEndAllowThreads(__tstate);
20731 if (PyErr_Occurred()) SWIG_fail;
20732 }
20733 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20734 return resultobj;
20735 fail:
20736 return NULL;
20737 }
20738
20739
20740 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20741 PyObject *resultobj = 0;
20742 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20743 int result;
20744 void *argp1 = 0 ;
20745 int res1 = 0 ;
20746 PyObject *swig_obj[1] ;
20747
20748 if (!args) SWIG_fail;
20749 swig_obj[0] = args;
20750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20751 if (!SWIG_IsOK(res1)) {
20752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20753 }
20754 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20755 {
20756 PyThreadState* __tstate = wxPyBeginAllowThreads();
20757 result = (int)((wxMouseEvent const *)arg1)->GetX();
20758 wxPyEndAllowThreads(__tstate);
20759 if (PyErr_Occurred()) SWIG_fail;
20760 }
20761 resultobj = SWIG_From_int(static_cast< int >(result));
20762 return resultobj;
20763 fail:
20764 return NULL;
20765 }
20766
20767
20768 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20769 PyObject *resultobj = 0;
20770 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20771 int result;
20772 void *argp1 = 0 ;
20773 int res1 = 0 ;
20774 PyObject *swig_obj[1] ;
20775
20776 if (!args) SWIG_fail;
20777 swig_obj[0] = args;
20778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20779 if (!SWIG_IsOK(res1)) {
20780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20781 }
20782 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20783 {
20784 PyThreadState* __tstate = wxPyBeginAllowThreads();
20785 result = (int)((wxMouseEvent const *)arg1)->GetY();
20786 wxPyEndAllowThreads(__tstate);
20787 if (PyErr_Occurred()) SWIG_fail;
20788 }
20789 resultobj = SWIG_From_int(static_cast< int >(result));
20790 return resultobj;
20791 fail:
20792 return NULL;
20793 }
20794
20795
20796 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20797 PyObject *resultobj = 0;
20798 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20799 int result;
20800 void *argp1 = 0 ;
20801 int res1 = 0 ;
20802 PyObject *swig_obj[1] ;
20803
20804 if (!args) SWIG_fail;
20805 swig_obj[0] = args;
20806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20807 if (!SWIG_IsOK(res1)) {
20808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20809 }
20810 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20811 {
20812 PyThreadState* __tstate = wxPyBeginAllowThreads();
20813 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20814 wxPyEndAllowThreads(__tstate);
20815 if (PyErr_Occurred()) SWIG_fail;
20816 }
20817 resultobj = SWIG_From_int(static_cast< int >(result));
20818 return resultobj;
20819 fail:
20820 return NULL;
20821 }
20822
20823
20824 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20825 PyObject *resultobj = 0;
20826 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20827 int result;
20828 void *argp1 = 0 ;
20829 int res1 = 0 ;
20830 PyObject *swig_obj[1] ;
20831
20832 if (!args) SWIG_fail;
20833 swig_obj[0] = args;
20834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20835 if (!SWIG_IsOK(res1)) {
20836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20837 }
20838 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20839 {
20840 PyThreadState* __tstate = wxPyBeginAllowThreads();
20841 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20842 wxPyEndAllowThreads(__tstate);
20843 if (PyErr_Occurred()) SWIG_fail;
20844 }
20845 resultobj = SWIG_From_int(static_cast< int >(result));
20846 return resultobj;
20847 fail:
20848 return NULL;
20849 }
20850
20851
20852 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20853 PyObject *resultobj = 0;
20854 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20855 int result;
20856 void *argp1 = 0 ;
20857 int res1 = 0 ;
20858 PyObject *swig_obj[1] ;
20859
20860 if (!args) SWIG_fail;
20861 swig_obj[0] = args;
20862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20863 if (!SWIG_IsOK(res1)) {
20864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20865 }
20866 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20867 {
20868 PyThreadState* __tstate = wxPyBeginAllowThreads();
20869 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20870 wxPyEndAllowThreads(__tstate);
20871 if (PyErr_Occurred()) SWIG_fail;
20872 }
20873 resultobj = SWIG_From_int(static_cast< int >(result));
20874 return resultobj;
20875 fail:
20876 return NULL;
20877 }
20878
20879
20880 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20881 PyObject *resultobj = 0;
20882 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20883 bool result;
20884 void *argp1 = 0 ;
20885 int res1 = 0 ;
20886 PyObject *swig_obj[1] ;
20887
20888 if (!args) SWIG_fail;
20889 swig_obj[0] = args;
20890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20891 if (!SWIG_IsOK(res1)) {
20892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20893 }
20894 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20895 {
20896 PyThreadState* __tstate = wxPyBeginAllowThreads();
20897 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20898 wxPyEndAllowThreads(__tstate);
20899 if (PyErr_Occurred()) SWIG_fail;
20900 }
20901 {
20902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20903 }
20904 return resultobj;
20905 fail:
20906 return NULL;
20907 }
20908
20909
20910 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20911 PyObject *resultobj = 0;
20912 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20913 int arg2 ;
20914 void *argp1 = 0 ;
20915 int res1 = 0 ;
20916 int val2 ;
20917 int ecode2 = 0 ;
20918 PyObject *swig_obj[2] ;
20919
20920 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20922 if (!SWIG_IsOK(res1)) {
20923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20924 }
20925 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20926 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20927 if (!SWIG_IsOK(ecode2)) {
20928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20929 }
20930 arg2 = static_cast< int >(val2);
20931 if (arg1) (arg1)->m_x = arg2;
20932
20933 resultobj = SWIG_Py_Void();
20934 return resultobj;
20935 fail:
20936 return NULL;
20937 }
20938
20939
20940 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20941 PyObject *resultobj = 0;
20942 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20943 int result;
20944 void *argp1 = 0 ;
20945 int res1 = 0 ;
20946 PyObject *swig_obj[1] ;
20947
20948 if (!args) SWIG_fail;
20949 swig_obj[0] = args;
20950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20951 if (!SWIG_IsOK(res1)) {
20952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20953 }
20954 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20955 result = (int) ((arg1)->m_x);
20956 resultobj = SWIG_From_int(static_cast< int >(result));
20957 return resultobj;
20958 fail:
20959 return NULL;
20960 }
20961
20962
20963 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20964 PyObject *resultobj = 0;
20965 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20966 int arg2 ;
20967 void *argp1 = 0 ;
20968 int res1 = 0 ;
20969 int val2 ;
20970 int ecode2 = 0 ;
20971 PyObject *swig_obj[2] ;
20972
20973 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
20974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20975 if (!SWIG_IsOK(res1)) {
20976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20977 }
20978 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20979 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20980 if (!SWIG_IsOK(ecode2)) {
20981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
20982 }
20983 arg2 = static_cast< int >(val2);
20984 if (arg1) (arg1)->m_y = arg2;
20985
20986 resultobj = SWIG_Py_Void();
20987 return resultobj;
20988 fail:
20989 return NULL;
20990 }
20991
20992
20993 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20994 PyObject *resultobj = 0;
20995 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20996 int result;
20997 void *argp1 = 0 ;
20998 int res1 = 0 ;
20999 PyObject *swig_obj[1] ;
21000
21001 if (!args) SWIG_fail;
21002 swig_obj[0] = args;
21003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21004 if (!SWIG_IsOK(res1)) {
21005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21006 }
21007 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21008 result = (int) ((arg1)->m_y);
21009 resultobj = SWIG_From_int(static_cast< int >(result));
21010 return resultobj;
21011 fail:
21012 return NULL;
21013 }
21014
21015
21016 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21017 PyObject *resultobj = 0;
21018 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21019 bool arg2 ;
21020 void *argp1 = 0 ;
21021 int res1 = 0 ;
21022 bool val2 ;
21023 int ecode2 = 0 ;
21024 PyObject *swig_obj[2] ;
21025
21026 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21028 if (!SWIG_IsOK(res1)) {
21029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21030 }
21031 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21032 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21033 if (!SWIG_IsOK(ecode2)) {
21034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21035 }
21036 arg2 = static_cast< bool >(val2);
21037 if (arg1) (arg1)->m_leftDown = arg2;
21038
21039 resultobj = SWIG_Py_Void();
21040 return resultobj;
21041 fail:
21042 return NULL;
21043 }
21044
21045
21046 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21047 PyObject *resultobj = 0;
21048 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21049 bool result;
21050 void *argp1 = 0 ;
21051 int res1 = 0 ;
21052 PyObject *swig_obj[1] ;
21053
21054 if (!args) SWIG_fail;
21055 swig_obj[0] = args;
21056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21057 if (!SWIG_IsOK(res1)) {
21058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21059 }
21060 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21061 result = (bool) ((arg1)->m_leftDown);
21062 {
21063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21064 }
21065 return resultobj;
21066 fail:
21067 return NULL;
21068 }
21069
21070
21071 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21072 PyObject *resultobj = 0;
21073 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21074 bool arg2 ;
21075 void *argp1 = 0 ;
21076 int res1 = 0 ;
21077 bool val2 ;
21078 int ecode2 = 0 ;
21079 PyObject *swig_obj[2] ;
21080
21081 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21083 if (!SWIG_IsOK(res1)) {
21084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21085 }
21086 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21087 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21088 if (!SWIG_IsOK(ecode2)) {
21089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21090 }
21091 arg2 = static_cast< bool >(val2);
21092 if (arg1) (arg1)->m_middleDown = arg2;
21093
21094 resultobj = SWIG_Py_Void();
21095 return resultobj;
21096 fail:
21097 return NULL;
21098 }
21099
21100
21101 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21102 PyObject *resultobj = 0;
21103 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21104 bool result;
21105 void *argp1 = 0 ;
21106 int res1 = 0 ;
21107 PyObject *swig_obj[1] ;
21108
21109 if (!args) SWIG_fail;
21110 swig_obj[0] = args;
21111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21112 if (!SWIG_IsOK(res1)) {
21113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21114 }
21115 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21116 result = (bool) ((arg1)->m_middleDown);
21117 {
21118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21119 }
21120 return resultobj;
21121 fail:
21122 return NULL;
21123 }
21124
21125
21126 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21127 PyObject *resultobj = 0;
21128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21129 bool arg2 ;
21130 void *argp1 = 0 ;
21131 int res1 = 0 ;
21132 bool val2 ;
21133 int ecode2 = 0 ;
21134 PyObject *swig_obj[2] ;
21135
21136 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21138 if (!SWIG_IsOK(res1)) {
21139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21140 }
21141 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21142 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21143 if (!SWIG_IsOK(ecode2)) {
21144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21145 }
21146 arg2 = static_cast< bool >(val2);
21147 if (arg1) (arg1)->m_rightDown = arg2;
21148
21149 resultobj = SWIG_Py_Void();
21150 return resultobj;
21151 fail:
21152 return NULL;
21153 }
21154
21155
21156 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21157 PyObject *resultobj = 0;
21158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21159 bool result;
21160 void *argp1 = 0 ;
21161 int res1 = 0 ;
21162 PyObject *swig_obj[1] ;
21163
21164 if (!args) SWIG_fail;
21165 swig_obj[0] = args;
21166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21167 if (!SWIG_IsOK(res1)) {
21168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21169 }
21170 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21171 result = (bool) ((arg1)->m_rightDown);
21172 {
21173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21174 }
21175 return resultobj;
21176 fail:
21177 return NULL;
21178 }
21179
21180
21181 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21182 PyObject *resultobj = 0;
21183 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21184 bool arg2 ;
21185 void *argp1 = 0 ;
21186 int res1 = 0 ;
21187 bool val2 ;
21188 int ecode2 = 0 ;
21189 PyObject *swig_obj[2] ;
21190
21191 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21193 if (!SWIG_IsOK(res1)) {
21194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21195 }
21196 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21197 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21198 if (!SWIG_IsOK(ecode2)) {
21199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21200 }
21201 arg2 = static_cast< bool >(val2);
21202 if (arg1) (arg1)->m_controlDown = arg2;
21203
21204 resultobj = SWIG_Py_Void();
21205 return resultobj;
21206 fail:
21207 return NULL;
21208 }
21209
21210
21211 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21212 PyObject *resultobj = 0;
21213 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21214 bool result;
21215 void *argp1 = 0 ;
21216 int res1 = 0 ;
21217 PyObject *swig_obj[1] ;
21218
21219 if (!args) SWIG_fail;
21220 swig_obj[0] = args;
21221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21222 if (!SWIG_IsOK(res1)) {
21223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21224 }
21225 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21226 result = (bool) ((arg1)->m_controlDown);
21227 {
21228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21229 }
21230 return resultobj;
21231 fail:
21232 return NULL;
21233 }
21234
21235
21236 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21237 PyObject *resultobj = 0;
21238 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21239 bool arg2 ;
21240 void *argp1 = 0 ;
21241 int res1 = 0 ;
21242 bool val2 ;
21243 int ecode2 = 0 ;
21244 PyObject *swig_obj[2] ;
21245
21246 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21248 if (!SWIG_IsOK(res1)) {
21249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21250 }
21251 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21252 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21253 if (!SWIG_IsOK(ecode2)) {
21254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21255 }
21256 arg2 = static_cast< bool >(val2);
21257 if (arg1) (arg1)->m_shiftDown = arg2;
21258
21259 resultobj = SWIG_Py_Void();
21260 return resultobj;
21261 fail:
21262 return NULL;
21263 }
21264
21265
21266 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21267 PyObject *resultobj = 0;
21268 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21269 bool result;
21270 void *argp1 = 0 ;
21271 int res1 = 0 ;
21272 PyObject *swig_obj[1] ;
21273
21274 if (!args) SWIG_fail;
21275 swig_obj[0] = args;
21276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21277 if (!SWIG_IsOK(res1)) {
21278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21279 }
21280 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21281 result = (bool) ((arg1)->m_shiftDown);
21282 {
21283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21284 }
21285 return resultobj;
21286 fail:
21287 return NULL;
21288 }
21289
21290
21291 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21292 PyObject *resultobj = 0;
21293 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21294 bool arg2 ;
21295 void *argp1 = 0 ;
21296 int res1 = 0 ;
21297 bool val2 ;
21298 int ecode2 = 0 ;
21299 PyObject *swig_obj[2] ;
21300
21301 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21303 if (!SWIG_IsOK(res1)) {
21304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21305 }
21306 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21307 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21308 if (!SWIG_IsOK(ecode2)) {
21309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21310 }
21311 arg2 = static_cast< bool >(val2);
21312 if (arg1) (arg1)->m_altDown = arg2;
21313
21314 resultobj = SWIG_Py_Void();
21315 return resultobj;
21316 fail:
21317 return NULL;
21318 }
21319
21320
21321 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21322 PyObject *resultobj = 0;
21323 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21324 bool result;
21325 void *argp1 = 0 ;
21326 int res1 = 0 ;
21327 PyObject *swig_obj[1] ;
21328
21329 if (!args) SWIG_fail;
21330 swig_obj[0] = args;
21331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21332 if (!SWIG_IsOK(res1)) {
21333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21334 }
21335 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21336 result = (bool) ((arg1)->m_altDown);
21337 {
21338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21339 }
21340 return resultobj;
21341 fail:
21342 return NULL;
21343 }
21344
21345
21346 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21347 PyObject *resultobj = 0;
21348 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21349 bool arg2 ;
21350 void *argp1 = 0 ;
21351 int res1 = 0 ;
21352 bool val2 ;
21353 int ecode2 = 0 ;
21354 PyObject *swig_obj[2] ;
21355
21356 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21358 if (!SWIG_IsOK(res1)) {
21359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21360 }
21361 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21362 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21363 if (!SWIG_IsOK(ecode2)) {
21364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21365 }
21366 arg2 = static_cast< bool >(val2);
21367 if (arg1) (arg1)->m_metaDown = arg2;
21368
21369 resultobj = SWIG_Py_Void();
21370 return resultobj;
21371 fail:
21372 return NULL;
21373 }
21374
21375
21376 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21377 PyObject *resultobj = 0;
21378 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21379 bool result;
21380 void *argp1 = 0 ;
21381 int res1 = 0 ;
21382 PyObject *swig_obj[1] ;
21383
21384 if (!args) SWIG_fail;
21385 swig_obj[0] = args;
21386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21387 if (!SWIG_IsOK(res1)) {
21388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21389 }
21390 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21391 result = (bool) ((arg1)->m_metaDown);
21392 {
21393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21394 }
21395 return resultobj;
21396 fail:
21397 return NULL;
21398 }
21399
21400
21401 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21402 PyObject *resultobj = 0;
21403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21404 int arg2 ;
21405 void *argp1 = 0 ;
21406 int res1 = 0 ;
21407 int val2 ;
21408 int ecode2 = 0 ;
21409 PyObject *swig_obj[2] ;
21410
21411 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21413 if (!SWIG_IsOK(res1)) {
21414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21415 }
21416 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21417 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21418 if (!SWIG_IsOK(ecode2)) {
21419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21420 }
21421 arg2 = static_cast< int >(val2);
21422 if (arg1) (arg1)->m_wheelRotation = arg2;
21423
21424 resultobj = SWIG_Py_Void();
21425 return resultobj;
21426 fail:
21427 return NULL;
21428 }
21429
21430
21431 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21432 PyObject *resultobj = 0;
21433 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21434 int result;
21435 void *argp1 = 0 ;
21436 int res1 = 0 ;
21437 PyObject *swig_obj[1] ;
21438
21439 if (!args) SWIG_fail;
21440 swig_obj[0] = args;
21441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21442 if (!SWIG_IsOK(res1)) {
21443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21444 }
21445 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21446 result = (int) ((arg1)->m_wheelRotation);
21447 resultobj = SWIG_From_int(static_cast< int >(result));
21448 return resultobj;
21449 fail:
21450 return NULL;
21451 }
21452
21453
21454 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21455 PyObject *resultobj = 0;
21456 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21457 int arg2 ;
21458 void *argp1 = 0 ;
21459 int res1 = 0 ;
21460 int val2 ;
21461 int ecode2 = 0 ;
21462 PyObject *swig_obj[2] ;
21463
21464 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21466 if (!SWIG_IsOK(res1)) {
21467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21468 }
21469 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21470 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21471 if (!SWIG_IsOK(ecode2)) {
21472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21473 }
21474 arg2 = static_cast< int >(val2);
21475 if (arg1) (arg1)->m_wheelDelta = arg2;
21476
21477 resultobj = SWIG_Py_Void();
21478 return resultobj;
21479 fail:
21480 return NULL;
21481 }
21482
21483
21484 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21485 PyObject *resultobj = 0;
21486 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21487 int result;
21488 void *argp1 = 0 ;
21489 int res1 = 0 ;
21490 PyObject *swig_obj[1] ;
21491
21492 if (!args) SWIG_fail;
21493 swig_obj[0] = args;
21494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21495 if (!SWIG_IsOK(res1)) {
21496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21497 }
21498 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21499 result = (int) ((arg1)->m_wheelDelta);
21500 resultobj = SWIG_From_int(static_cast< int >(result));
21501 return resultobj;
21502 fail:
21503 return NULL;
21504 }
21505
21506
21507 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21508 PyObject *resultobj = 0;
21509 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21510 int arg2 ;
21511 void *argp1 = 0 ;
21512 int res1 = 0 ;
21513 int val2 ;
21514 int ecode2 = 0 ;
21515 PyObject *swig_obj[2] ;
21516
21517 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21519 if (!SWIG_IsOK(res1)) {
21520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21521 }
21522 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21523 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21524 if (!SWIG_IsOK(ecode2)) {
21525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21526 }
21527 arg2 = static_cast< int >(val2);
21528 if (arg1) (arg1)->m_linesPerAction = arg2;
21529
21530 resultobj = SWIG_Py_Void();
21531 return resultobj;
21532 fail:
21533 return NULL;
21534 }
21535
21536
21537 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21538 PyObject *resultobj = 0;
21539 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21540 int result;
21541 void *argp1 = 0 ;
21542 int res1 = 0 ;
21543 PyObject *swig_obj[1] ;
21544
21545 if (!args) SWIG_fail;
21546 swig_obj[0] = args;
21547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21548 if (!SWIG_IsOK(res1)) {
21549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21550 }
21551 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21552 result = (int) ((arg1)->m_linesPerAction);
21553 resultobj = SWIG_From_int(static_cast< int >(result));
21554 return resultobj;
21555 fail:
21556 return NULL;
21557 }
21558
21559
21560 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21561 PyObject *obj;
21562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21563 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21564 return SWIG_Py_Void();
21565 }
21566
21567 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21568 return SWIG_Python_InitShadowInstance(args);
21569 }
21570
21571 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21572 PyObject *resultobj = 0;
21573 int arg1 = (int) 0 ;
21574 int arg2 = (int) 0 ;
21575 wxSetCursorEvent *result = 0 ;
21576 int val1 ;
21577 int ecode1 = 0 ;
21578 int val2 ;
21579 int ecode2 = 0 ;
21580 PyObject * obj0 = 0 ;
21581 PyObject * obj1 = 0 ;
21582 char * kwnames[] = {
21583 (char *) "x",(char *) "y", NULL
21584 };
21585
21586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21587 if (obj0) {
21588 ecode1 = SWIG_AsVal_int(obj0, &val1);
21589 if (!SWIG_IsOK(ecode1)) {
21590 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21591 }
21592 arg1 = static_cast< int >(val1);
21593 }
21594 if (obj1) {
21595 ecode2 = SWIG_AsVal_int(obj1, &val2);
21596 if (!SWIG_IsOK(ecode2)) {
21597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21598 }
21599 arg2 = static_cast< int >(val2);
21600 }
21601 {
21602 PyThreadState* __tstate = wxPyBeginAllowThreads();
21603 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21604 wxPyEndAllowThreads(__tstate);
21605 if (PyErr_Occurred()) SWIG_fail;
21606 }
21607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21608 return resultobj;
21609 fail:
21610 return NULL;
21611 }
21612
21613
21614 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21615 PyObject *resultobj = 0;
21616 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21617 int result;
21618 void *argp1 = 0 ;
21619 int res1 = 0 ;
21620 PyObject *swig_obj[1] ;
21621
21622 if (!args) SWIG_fail;
21623 swig_obj[0] = args;
21624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21625 if (!SWIG_IsOK(res1)) {
21626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21627 }
21628 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21629 {
21630 PyThreadState* __tstate = wxPyBeginAllowThreads();
21631 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21632 wxPyEndAllowThreads(__tstate);
21633 if (PyErr_Occurred()) SWIG_fail;
21634 }
21635 resultobj = SWIG_From_int(static_cast< int >(result));
21636 return resultobj;
21637 fail:
21638 return NULL;
21639 }
21640
21641
21642 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21643 PyObject *resultobj = 0;
21644 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21645 int result;
21646 void *argp1 = 0 ;
21647 int res1 = 0 ;
21648 PyObject *swig_obj[1] ;
21649
21650 if (!args) SWIG_fail;
21651 swig_obj[0] = args;
21652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21653 if (!SWIG_IsOK(res1)) {
21654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21655 }
21656 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21657 {
21658 PyThreadState* __tstate = wxPyBeginAllowThreads();
21659 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21660 wxPyEndAllowThreads(__tstate);
21661 if (PyErr_Occurred()) SWIG_fail;
21662 }
21663 resultobj = SWIG_From_int(static_cast< int >(result));
21664 return resultobj;
21665 fail:
21666 return NULL;
21667 }
21668
21669
21670 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21671 PyObject *resultobj = 0;
21672 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21673 wxCursor *arg2 = 0 ;
21674 void *argp1 = 0 ;
21675 int res1 = 0 ;
21676 void *argp2 = 0 ;
21677 int res2 = 0 ;
21678 PyObject * obj0 = 0 ;
21679 PyObject * obj1 = 0 ;
21680 char * kwnames[] = {
21681 (char *) "self",(char *) "cursor", NULL
21682 };
21683
21684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21686 if (!SWIG_IsOK(res1)) {
21687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21688 }
21689 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21690 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21691 if (!SWIG_IsOK(res2)) {
21692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21693 }
21694 if (!argp2) {
21695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21696 }
21697 arg2 = reinterpret_cast< wxCursor * >(argp2);
21698 {
21699 PyThreadState* __tstate = wxPyBeginAllowThreads();
21700 (arg1)->SetCursor((wxCursor const &)*arg2);
21701 wxPyEndAllowThreads(__tstate);
21702 if (PyErr_Occurred()) SWIG_fail;
21703 }
21704 resultobj = SWIG_Py_Void();
21705 return resultobj;
21706 fail:
21707 return NULL;
21708 }
21709
21710
21711 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21712 PyObject *resultobj = 0;
21713 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21714 wxCursor *result = 0 ;
21715 void *argp1 = 0 ;
21716 int res1 = 0 ;
21717 PyObject *swig_obj[1] ;
21718
21719 if (!args) SWIG_fail;
21720 swig_obj[0] = args;
21721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21722 if (!SWIG_IsOK(res1)) {
21723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21724 }
21725 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21726 {
21727 PyThreadState* __tstate = wxPyBeginAllowThreads();
21728 {
21729 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21730 result = (wxCursor *) &_result_ref;
21731 }
21732 wxPyEndAllowThreads(__tstate);
21733 if (PyErr_Occurred()) SWIG_fail;
21734 }
21735 {
21736 wxCursor* resultptr = new wxCursor(*result);
21737 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21738 }
21739 return resultobj;
21740 fail:
21741 return NULL;
21742 }
21743
21744
21745 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21746 PyObject *resultobj = 0;
21747 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21748 bool result;
21749 void *argp1 = 0 ;
21750 int res1 = 0 ;
21751 PyObject *swig_obj[1] ;
21752
21753 if (!args) SWIG_fail;
21754 swig_obj[0] = args;
21755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21756 if (!SWIG_IsOK(res1)) {
21757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21758 }
21759 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21760 {
21761 PyThreadState* __tstate = wxPyBeginAllowThreads();
21762 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21763 wxPyEndAllowThreads(__tstate);
21764 if (PyErr_Occurred()) SWIG_fail;
21765 }
21766 {
21767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21768 }
21769 return resultobj;
21770 fail:
21771 return NULL;
21772 }
21773
21774
21775 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21776 PyObject *obj;
21777 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21778 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21779 return SWIG_Py_Void();
21780 }
21781
21782 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21783 return SWIG_Python_InitShadowInstance(args);
21784 }
21785
21786 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21787 PyObject *resultobj = 0;
21788 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21789 wxKeyEvent *result = 0 ;
21790 int val1 ;
21791 int ecode1 = 0 ;
21792 PyObject * obj0 = 0 ;
21793 char * kwnames[] = {
21794 (char *) "eventType", NULL
21795 };
21796
21797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21798 if (obj0) {
21799 ecode1 = SWIG_AsVal_int(obj0, &val1);
21800 if (!SWIG_IsOK(ecode1)) {
21801 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21802 }
21803 arg1 = static_cast< wxEventType >(val1);
21804 }
21805 {
21806 PyThreadState* __tstate = wxPyBeginAllowThreads();
21807 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21808 wxPyEndAllowThreads(__tstate);
21809 if (PyErr_Occurred()) SWIG_fail;
21810 }
21811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21812 return resultobj;
21813 fail:
21814 return NULL;
21815 }
21816
21817
21818 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21819 PyObject *resultobj = 0;
21820 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21821 int result;
21822 void *argp1 = 0 ;
21823 int res1 = 0 ;
21824 PyObject *swig_obj[1] ;
21825
21826 if (!args) SWIG_fail;
21827 swig_obj[0] = args;
21828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21829 if (!SWIG_IsOK(res1)) {
21830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21831 }
21832 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21833 {
21834 PyThreadState* __tstate = wxPyBeginAllowThreads();
21835 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21836 wxPyEndAllowThreads(__tstate);
21837 if (PyErr_Occurred()) SWIG_fail;
21838 }
21839 resultobj = SWIG_From_int(static_cast< int >(result));
21840 return resultobj;
21841 fail:
21842 return NULL;
21843 }
21844
21845
21846 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21847 PyObject *resultobj = 0;
21848 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21849 bool result;
21850 void *argp1 = 0 ;
21851 int res1 = 0 ;
21852 PyObject *swig_obj[1] ;
21853
21854 if (!args) SWIG_fail;
21855 swig_obj[0] = args;
21856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21857 if (!SWIG_IsOK(res1)) {
21858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21859 }
21860 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21861 {
21862 PyThreadState* __tstate = wxPyBeginAllowThreads();
21863 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21864 wxPyEndAllowThreads(__tstate);
21865 if (PyErr_Occurred()) SWIG_fail;
21866 }
21867 {
21868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21869 }
21870 return resultobj;
21871 fail:
21872 return NULL;
21873 }
21874
21875
21876 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21877 PyObject *resultobj = 0;
21878 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21879 bool result;
21880 void *argp1 = 0 ;
21881 int res1 = 0 ;
21882 PyObject *swig_obj[1] ;
21883
21884 if (!args) SWIG_fail;
21885 swig_obj[0] = args;
21886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21887 if (!SWIG_IsOK(res1)) {
21888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21889 }
21890 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21891 {
21892 PyThreadState* __tstate = wxPyBeginAllowThreads();
21893 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21894 wxPyEndAllowThreads(__tstate);
21895 if (PyErr_Occurred()) SWIG_fail;
21896 }
21897 {
21898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21899 }
21900 return resultobj;
21901 fail:
21902 return NULL;
21903 }
21904
21905
21906 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21907 PyObject *resultobj = 0;
21908 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21909 bool result;
21910 void *argp1 = 0 ;
21911 int res1 = 0 ;
21912 PyObject *swig_obj[1] ;
21913
21914 if (!args) SWIG_fail;
21915 swig_obj[0] = args;
21916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21917 if (!SWIG_IsOK(res1)) {
21918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21919 }
21920 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21921 {
21922 PyThreadState* __tstate = wxPyBeginAllowThreads();
21923 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21924 wxPyEndAllowThreads(__tstate);
21925 if (PyErr_Occurred()) SWIG_fail;
21926 }
21927 {
21928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21929 }
21930 return resultobj;
21931 fail:
21932 return NULL;
21933 }
21934
21935
21936 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21937 PyObject *resultobj = 0;
21938 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21939 bool result;
21940 void *argp1 = 0 ;
21941 int res1 = 0 ;
21942 PyObject *swig_obj[1] ;
21943
21944 if (!args) SWIG_fail;
21945 swig_obj[0] = args;
21946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21947 if (!SWIG_IsOK(res1)) {
21948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21949 }
21950 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21951 {
21952 PyThreadState* __tstate = wxPyBeginAllowThreads();
21953 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
21954 wxPyEndAllowThreads(__tstate);
21955 if (PyErr_Occurred()) SWIG_fail;
21956 }
21957 {
21958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21959 }
21960 return resultobj;
21961 fail:
21962 return NULL;
21963 }
21964
21965
21966 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21967 PyObject *resultobj = 0;
21968 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21969 bool result;
21970 void *argp1 = 0 ;
21971 int res1 = 0 ;
21972 PyObject *swig_obj[1] ;
21973
21974 if (!args) SWIG_fail;
21975 swig_obj[0] = args;
21976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21977 if (!SWIG_IsOK(res1)) {
21978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21979 }
21980 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21981 {
21982 PyThreadState* __tstate = wxPyBeginAllowThreads();
21983 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
21984 wxPyEndAllowThreads(__tstate);
21985 if (PyErr_Occurred()) SWIG_fail;
21986 }
21987 {
21988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21989 }
21990 return resultobj;
21991 fail:
21992 return NULL;
21993 }
21994
21995
21996 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21997 PyObject *resultobj = 0;
21998 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21999 bool result;
22000 void *argp1 = 0 ;
22001 int res1 = 0 ;
22002 PyObject *swig_obj[1] ;
22003
22004 if (!args) SWIG_fail;
22005 swig_obj[0] = args;
22006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22007 if (!SWIG_IsOK(res1)) {
22008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22009 }
22010 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22011 {
22012 PyThreadState* __tstate = wxPyBeginAllowThreads();
22013 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22014 wxPyEndAllowThreads(__tstate);
22015 if (PyErr_Occurred()) SWIG_fail;
22016 }
22017 {
22018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22019 }
22020 return resultobj;
22021 fail:
22022 return NULL;
22023 }
22024
22025
22026 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22027 PyObject *resultobj = 0;
22028 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22029 int result;
22030 void *argp1 = 0 ;
22031 int res1 = 0 ;
22032 PyObject *swig_obj[1] ;
22033
22034 if (!args) SWIG_fail;
22035 swig_obj[0] = args;
22036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22037 if (!SWIG_IsOK(res1)) {
22038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22039 }
22040 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22041 {
22042 PyThreadState* __tstate = wxPyBeginAllowThreads();
22043 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22044 wxPyEndAllowThreads(__tstate);
22045 if (PyErr_Occurred()) SWIG_fail;
22046 }
22047 resultobj = SWIG_From_int(static_cast< int >(result));
22048 return resultobj;
22049 fail:
22050 return NULL;
22051 }
22052
22053
22054 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22055 PyObject *resultobj = 0;
22056 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22057 int result;
22058 void *argp1 = 0 ;
22059 int res1 = 0 ;
22060 PyObject *swig_obj[1] ;
22061
22062 if (!args) SWIG_fail;
22063 swig_obj[0] = args;
22064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22065 if (!SWIG_IsOK(res1)) {
22066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22067 }
22068 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22069 {
22070 PyThreadState* __tstate = wxPyBeginAllowThreads();
22071 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22072 wxPyEndAllowThreads(__tstate);
22073 if (PyErr_Occurred()) SWIG_fail;
22074 }
22075 resultobj = SWIG_From_int(static_cast< int >(result));
22076 return resultobj;
22077 fail:
22078 return NULL;
22079 }
22080
22081
22082 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22083 PyObject *resultobj = 0;
22084 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22085 unsigned int result;
22086 void *argp1 = 0 ;
22087 int res1 = 0 ;
22088 PyObject *swig_obj[1] ;
22089
22090 if (!args) SWIG_fail;
22091 swig_obj[0] = args;
22092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22093 if (!SWIG_IsOK(res1)) {
22094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22095 }
22096 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22097 {
22098 PyThreadState* __tstate = wxPyBeginAllowThreads();
22099 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22100 wxPyEndAllowThreads(__tstate);
22101 if (PyErr_Occurred()) SWIG_fail;
22102 }
22103 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22104 return resultobj;
22105 fail:
22106 return NULL;
22107 }
22108
22109
22110 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22111 PyObject *resultobj = 0;
22112 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22113 unsigned int result;
22114 void *argp1 = 0 ;
22115 int res1 = 0 ;
22116 PyObject *swig_obj[1] ;
22117
22118 if (!args) SWIG_fail;
22119 swig_obj[0] = args;
22120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22121 if (!SWIG_IsOK(res1)) {
22122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22123 }
22124 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22125 {
22126 PyThreadState* __tstate = wxPyBeginAllowThreads();
22127 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22128 wxPyEndAllowThreads(__tstate);
22129 if (PyErr_Occurred()) SWIG_fail;
22130 }
22131 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22139 PyObject *resultobj = 0;
22140 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22141 wxPoint result;
22142 void *argp1 = 0 ;
22143 int res1 = 0 ;
22144 PyObject *swig_obj[1] ;
22145
22146 if (!args) SWIG_fail;
22147 swig_obj[0] = args;
22148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22149 if (!SWIG_IsOK(res1)) {
22150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22151 }
22152 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22153 {
22154 PyThreadState* __tstate = wxPyBeginAllowThreads();
22155 result = (arg1)->GetPosition();
22156 wxPyEndAllowThreads(__tstate);
22157 if (PyErr_Occurred()) SWIG_fail;
22158 }
22159 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22160 return resultobj;
22161 fail:
22162 return NULL;
22163 }
22164
22165
22166 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22167 PyObject *resultobj = 0;
22168 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22169 long *arg2 = (long *) 0 ;
22170 long *arg3 = (long *) 0 ;
22171 void *argp1 = 0 ;
22172 int res1 = 0 ;
22173 long temp2 ;
22174 int res2 = SWIG_TMPOBJ ;
22175 long temp3 ;
22176 int res3 = SWIG_TMPOBJ ;
22177 PyObject *swig_obj[1] ;
22178
22179 arg2 = &temp2;
22180 arg3 = &temp3;
22181 if (!args) SWIG_fail;
22182 swig_obj[0] = args;
22183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22184 if (!SWIG_IsOK(res1)) {
22185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22186 }
22187 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22188 {
22189 PyThreadState* __tstate = wxPyBeginAllowThreads();
22190 (arg1)->GetPosition(arg2,arg3);
22191 wxPyEndAllowThreads(__tstate);
22192 if (PyErr_Occurred()) SWIG_fail;
22193 }
22194 resultobj = SWIG_Py_Void();
22195 if (SWIG_IsTmpObj(res2)) {
22196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22197 } else {
22198 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22200 }
22201 if (SWIG_IsTmpObj(res3)) {
22202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22203 } else {
22204 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22206 }
22207 return resultobj;
22208 fail:
22209 return NULL;
22210 }
22211
22212
22213 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22214 PyObject *resultobj = 0;
22215 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22216 int result;
22217 void *argp1 = 0 ;
22218 int res1 = 0 ;
22219 PyObject *swig_obj[1] ;
22220
22221 if (!args) SWIG_fail;
22222 swig_obj[0] = args;
22223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22224 if (!SWIG_IsOK(res1)) {
22225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22226 }
22227 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22228 {
22229 PyThreadState* __tstate = wxPyBeginAllowThreads();
22230 result = (int)((wxKeyEvent const *)arg1)->GetX();
22231 wxPyEndAllowThreads(__tstate);
22232 if (PyErr_Occurred()) SWIG_fail;
22233 }
22234 resultobj = SWIG_From_int(static_cast< int >(result));
22235 return resultobj;
22236 fail:
22237 return NULL;
22238 }
22239
22240
22241 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22242 PyObject *resultobj = 0;
22243 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22244 int result;
22245 void *argp1 = 0 ;
22246 int res1 = 0 ;
22247 PyObject *swig_obj[1] ;
22248
22249 if (!args) SWIG_fail;
22250 swig_obj[0] = args;
22251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22252 if (!SWIG_IsOK(res1)) {
22253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22254 }
22255 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22256 {
22257 PyThreadState* __tstate = wxPyBeginAllowThreads();
22258 result = (int)((wxKeyEvent const *)arg1)->GetY();
22259 wxPyEndAllowThreads(__tstate);
22260 if (PyErr_Occurred()) SWIG_fail;
22261 }
22262 resultobj = SWIG_From_int(static_cast< int >(result));
22263 return resultobj;
22264 fail:
22265 return NULL;
22266 }
22267
22268
22269 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22270 PyObject *resultobj = 0;
22271 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22272 int arg2 ;
22273 void *argp1 = 0 ;
22274 int res1 = 0 ;
22275 int val2 ;
22276 int ecode2 = 0 ;
22277 PyObject *swig_obj[2] ;
22278
22279 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22281 if (!SWIG_IsOK(res1)) {
22282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22283 }
22284 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22285 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22286 if (!SWIG_IsOK(ecode2)) {
22287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22288 }
22289 arg2 = static_cast< int >(val2);
22290 if (arg1) (arg1)->m_x = arg2;
22291
22292 resultobj = SWIG_Py_Void();
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22300 PyObject *resultobj = 0;
22301 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22302 int result;
22303 void *argp1 = 0 ;
22304 int res1 = 0 ;
22305 PyObject *swig_obj[1] ;
22306
22307 if (!args) SWIG_fail;
22308 swig_obj[0] = args;
22309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22310 if (!SWIG_IsOK(res1)) {
22311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22312 }
22313 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22314 result = (int) ((arg1)->m_x);
22315 resultobj = SWIG_From_int(static_cast< int >(result));
22316 return resultobj;
22317 fail:
22318 return NULL;
22319 }
22320
22321
22322 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22323 PyObject *resultobj = 0;
22324 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22325 int arg2 ;
22326 void *argp1 = 0 ;
22327 int res1 = 0 ;
22328 int val2 ;
22329 int ecode2 = 0 ;
22330 PyObject *swig_obj[2] ;
22331
22332 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22334 if (!SWIG_IsOK(res1)) {
22335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22336 }
22337 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22338 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22339 if (!SWIG_IsOK(ecode2)) {
22340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22341 }
22342 arg2 = static_cast< int >(val2);
22343 if (arg1) (arg1)->m_y = arg2;
22344
22345 resultobj = SWIG_Py_Void();
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22353 PyObject *resultobj = 0;
22354 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22355 int result;
22356 void *argp1 = 0 ;
22357 int res1 = 0 ;
22358 PyObject *swig_obj[1] ;
22359
22360 if (!args) SWIG_fail;
22361 swig_obj[0] = args;
22362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22363 if (!SWIG_IsOK(res1)) {
22364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22365 }
22366 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22367 result = (int) ((arg1)->m_y);
22368 resultobj = SWIG_From_int(static_cast< int >(result));
22369 return resultobj;
22370 fail:
22371 return NULL;
22372 }
22373
22374
22375 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22376 PyObject *resultobj = 0;
22377 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22378 long arg2 ;
22379 void *argp1 = 0 ;
22380 int res1 = 0 ;
22381 long val2 ;
22382 int ecode2 = 0 ;
22383 PyObject *swig_obj[2] ;
22384
22385 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22387 if (!SWIG_IsOK(res1)) {
22388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22389 }
22390 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22391 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22392 if (!SWIG_IsOK(ecode2)) {
22393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22394 }
22395 arg2 = static_cast< long >(val2);
22396 if (arg1) (arg1)->m_keyCode = arg2;
22397
22398 resultobj = SWIG_Py_Void();
22399 return resultobj;
22400 fail:
22401 return NULL;
22402 }
22403
22404
22405 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22406 PyObject *resultobj = 0;
22407 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22408 long result;
22409 void *argp1 = 0 ;
22410 int res1 = 0 ;
22411 PyObject *swig_obj[1] ;
22412
22413 if (!args) SWIG_fail;
22414 swig_obj[0] = args;
22415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22416 if (!SWIG_IsOK(res1)) {
22417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22418 }
22419 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22420 result = (long) ((arg1)->m_keyCode);
22421 resultobj = SWIG_From_long(static_cast< long >(result));
22422 return resultobj;
22423 fail:
22424 return NULL;
22425 }
22426
22427
22428 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22429 PyObject *resultobj = 0;
22430 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22431 bool arg2 ;
22432 void *argp1 = 0 ;
22433 int res1 = 0 ;
22434 bool val2 ;
22435 int ecode2 = 0 ;
22436 PyObject *swig_obj[2] ;
22437
22438 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22440 if (!SWIG_IsOK(res1)) {
22441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22442 }
22443 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22444 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22445 if (!SWIG_IsOK(ecode2)) {
22446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22447 }
22448 arg2 = static_cast< bool >(val2);
22449 if (arg1) (arg1)->m_controlDown = arg2;
22450
22451 resultobj = SWIG_Py_Void();
22452 return resultobj;
22453 fail:
22454 return NULL;
22455 }
22456
22457
22458 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22459 PyObject *resultobj = 0;
22460 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22461 bool result;
22462 void *argp1 = 0 ;
22463 int res1 = 0 ;
22464 PyObject *swig_obj[1] ;
22465
22466 if (!args) SWIG_fail;
22467 swig_obj[0] = args;
22468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22469 if (!SWIG_IsOK(res1)) {
22470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22471 }
22472 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22473 result = (bool) ((arg1)->m_controlDown);
22474 {
22475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22476 }
22477 return resultobj;
22478 fail:
22479 return NULL;
22480 }
22481
22482
22483 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22484 PyObject *resultobj = 0;
22485 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22486 bool arg2 ;
22487 void *argp1 = 0 ;
22488 int res1 = 0 ;
22489 bool val2 ;
22490 int ecode2 = 0 ;
22491 PyObject *swig_obj[2] ;
22492
22493 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22495 if (!SWIG_IsOK(res1)) {
22496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22497 }
22498 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22499 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22500 if (!SWIG_IsOK(ecode2)) {
22501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22502 }
22503 arg2 = static_cast< bool >(val2);
22504 if (arg1) (arg1)->m_shiftDown = arg2;
22505
22506 resultobj = SWIG_Py_Void();
22507 return resultobj;
22508 fail:
22509 return NULL;
22510 }
22511
22512
22513 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22514 PyObject *resultobj = 0;
22515 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22516 bool result;
22517 void *argp1 = 0 ;
22518 int res1 = 0 ;
22519 PyObject *swig_obj[1] ;
22520
22521 if (!args) SWIG_fail;
22522 swig_obj[0] = args;
22523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22524 if (!SWIG_IsOK(res1)) {
22525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22526 }
22527 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22528 result = (bool) ((arg1)->m_shiftDown);
22529 {
22530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22531 }
22532 return resultobj;
22533 fail:
22534 return NULL;
22535 }
22536
22537
22538 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22539 PyObject *resultobj = 0;
22540 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22541 bool arg2 ;
22542 void *argp1 = 0 ;
22543 int res1 = 0 ;
22544 bool val2 ;
22545 int ecode2 = 0 ;
22546 PyObject *swig_obj[2] ;
22547
22548 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22550 if (!SWIG_IsOK(res1)) {
22551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22552 }
22553 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22554 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22555 if (!SWIG_IsOK(ecode2)) {
22556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22557 }
22558 arg2 = static_cast< bool >(val2);
22559 if (arg1) (arg1)->m_altDown = arg2;
22560
22561 resultobj = SWIG_Py_Void();
22562 return resultobj;
22563 fail:
22564 return NULL;
22565 }
22566
22567
22568 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22569 PyObject *resultobj = 0;
22570 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22571 bool result;
22572 void *argp1 = 0 ;
22573 int res1 = 0 ;
22574 PyObject *swig_obj[1] ;
22575
22576 if (!args) SWIG_fail;
22577 swig_obj[0] = args;
22578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22579 if (!SWIG_IsOK(res1)) {
22580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22581 }
22582 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22583 result = (bool) ((arg1)->m_altDown);
22584 {
22585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22586 }
22587 return resultobj;
22588 fail:
22589 return NULL;
22590 }
22591
22592
22593 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22594 PyObject *resultobj = 0;
22595 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22596 bool arg2 ;
22597 void *argp1 = 0 ;
22598 int res1 = 0 ;
22599 bool val2 ;
22600 int ecode2 = 0 ;
22601 PyObject *swig_obj[2] ;
22602
22603 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22605 if (!SWIG_IsOK(res1)) {
22606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22607 }
22608 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22609 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22610 if (!SWIG_IsOK(ecode2)) {
22611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22612 }
22613 arg2 = static_cast< bool >(val2);
22614 if (arg1) (arg1)->m_metaDown = arg2;
22615
22616 resultobj = SWIG_Py_Void();
22617 return resultobj;
22618 fail:
22619 return NULL;
22620 }
22621
22622
22623 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22624 PyObject *resultobj = 0;
22625 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22626 bool result;
22627 void *argp1 = 0 ;
22628 int res1 = 0 ;
22629 PyObject *swig_obj[1] ;
22630
22631 if (!args) SWIG_fail;
22632 swig_obj[0] = args;
22633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22634 if (!SWIG_IsOK(res1)) {
22635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22636 }
22637 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22638 result = (bool) ((arg1)->m_metaDown);
22639 {
22640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22641 }
22642 return resultobj;
22643 fail:
22644 return NULL;
22645 }
22646
22647
22648 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22649 PyObject *resultobj = 0;
22650 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22651 bool arg2 ;
22652 void *argp1 = 0 ;
22653 int res1 = 0 ;
22654 bool val2 ;
22655 int ecode2 = 0 ;
22656 PyObject *swig_obj[2] ;
22657
22658 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22660 if (!SWIG_IsOK(res1)) {
22661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22662 }
22663 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22664 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22665 if (!SWIG_IsOK(ecode2)) {
22666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22667 }
22668 arg2 = static_cast< bool >(val2);
22669 if (arg1) (arg1)->m_scanCode = arg2;
22670
22671 resultobj = SWIG_Py_Void();
22672 return resultobj;
22673 fail:
22674 return NULL;
22675 }
22676
22677
22678 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22679 PyObject *resultobj = 0;
22680 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22681 bool result;
22682 void *argp1 = 0 ;
22683 int res1 = 0 ;
22684 PyObject *swig_obj[1] ;
22685
22686 if (!args) SWIG_fail;
22687 swig_obj[0] = args;
22688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22689 if (!SWIG_IsOK(res1)) {
22690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22691 }
22692 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22693 result = (bool) ((arg1)->m_scanCode);
22694 {
22695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22696 }
22697 return resultobj;
22698 fail:
22699 return NULL;
22700 }
22701
22702
22703 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22704 PyObject *resultobj = 0;
22705 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22706 unsigned int arg2 ;
22707 void *argp1 = 0 ;
22708 int res1 = 0 ;
22709 unsigned int val2 ;
22710 int ecode2 = 0 ;
22711 PyObject *swig_obj[2] ;
22712
22713 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22715 if (!SWIG_IsOK(res1)) {
22716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22717 }
22718 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22719 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22720 if (!SWIG_IsOK(ecode2)) {
22721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22722 }
22723 arg2 = static_cast< unsigned int >(val2);
22724 if (arg1) (arg1)->m_rawCode = arg2;
22725
22726 resultobj = SWIG_Py_Void();
22727 return resultobj;
22728 fail:
22729 return NULL;
22730 }
22731
22732
22733 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22734 PyObject *resultobj = 0;
22735 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22736 unsigned int result;
22737 void *argp1 = 0 ;
22738 int res1 = 0 ;
22739 PyObject *swig_obj[1] ;
22740
22741 if (!args) SWIG_fail;
22742 swig_obj[0] = args;
22743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22744 if (!SWIG_IsOK(res1)) {
22745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22746 }
22747 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22748 result = (unsigned int) ((arg1)->m_rawCode);
22749 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22750 return resultobj;
22751 fail:
22752 return NULL;
22753 }
22754
22755
22756 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22757 PyObject *resultobj = 0;
22758 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22759 unsigned int arg2 ;
22760 void *argp1 = 0 ;
22761 int res1 = 0 ;
22762 unsigned int val2 ;
22763 int ecode2 = 0 ;
22764 PyObject *swig_obj[2] ;
22765
22766 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22768 if (!SWIG_IsOK(res1)) {
22769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22770 }
22771 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22772 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22773 if (!SWIG_IsOK(ecode2)) {
22774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22775 }
22776 arg2 = static_cast< unsigned int >(val2);
22777 if (arg1) (arg1)->m_rawFlags = arg2;
22778
22779 resultobj = SWIG_Py_Void();
22780 return resultobj;
22781 fail:
22782 return NULL;
22783 }
22784
22785
22786 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22787 PyObject *resultobj = 0;
22788 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22789 unsigned int result;
22790 void *argp1 = 0 ;
22791 int res1 = 0 ;
22792 PyObject *swig_obj[1] ;
22793
22794 if (!args) SWIG_fail;
22795 swig_obj[0] = args;
22796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22797 if (!SWIG_IsOK(res1)) {
22798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22799 }
22800 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22801 result = (unsigned int) ((arg1)->m_rawFlags);
22802 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22803 return resultobj;
22804 fail:
22805 return NULL;
22806 }
22807
22808
22809 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22810 PyObject *obj;
22811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22812 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22813 return SWIG_Py_Void();
22814 }
22815
22816 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22817 return SWIG_Python_InitShadowInstance(args);
22818 }
22819
22820 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22821 PyObject *resultobj = 0;
22822 wxSize const &arg1_defvalue = wxDefaultSize ;
22823 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22824 int arg2 = (int) 0 ;
22825 wxSizeEvent *result = 0 ;
22826 wxSize temp1 ;
22827 int val2 ;
22828 int ecode2 = 0 ;
22829 PyObject * obj0 = 0 ;
22830 PyObject * obj1 = 0 ;
22831 char * kwnames[] = {
22832 (char *) "sz",(char *) "winid", NULL
22833 };
22834
22835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22836 if (obj0) {
22837 {
22838 arg1 = &temp1;
22839 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22840 }
22841 }
22842 if (obj1) {
22843 ecode2 = SWIG_AsVal_int(obj1, &val2);
22844 if (!SWIG_IsOK(ecode2)) {
22845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22846 }
22847 arg2 = static_cast< int >(val2);
22848 }
22849 {
22850 PyThreadState* __tstate = wxPyBeginAllowThreads();
22851 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22852 wxPyEndAllowThreads(__tstate);
22853 if (PyErr_Occurred()) SWIG_fail;
22854 }
22855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22856 return resultobj;
22857 fail:
22858 return NULL;
22859 }
22860
22861
22862 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22863 PyObject *resultobj = 0;
22864 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22865 wxSize result;
22866 void *argp1 = 0 ;
22867 int res1 = 0 ;
22868 PyObject *swig_obj[1] ;
22869
22870 if (!args) SWIG_fail;
22871 swig_obj[0] = args;
22872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22873 if (!SWIG_IsOK(res1)) {
22874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22875 }
22876 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22877 {
22878 PyThreadState* __tstate = wxPyBeginAllowThreads();
22879 result = ((wxSizeEvent const *)arg1)->GetSize();
22880 wxPyEndAllowThreads(__tstate);
22881 if (PyErr_Occurred()) SWIG_fail;
22882 }
22883 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22884 return resultobj;
22885 fail:
22886 return NULL;
22887 }
22888
22889
22890 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22891 PyObject *resultobj = 0;
22892 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22893 wxRect result;
22894 void *argp1 = 0 ;
22895 int res1 = 0 ;
22896 PyObject *swig_obj[1] ;
22897
22898 if (!args) SWIG_fail;
22899 swig_obj[0] = args;
22900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22901 if (!SWIG_IsOK(res1)) {
22902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22903 }
22904 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22905 {
22906 PyThreadState* __tstate = wxPyBeginAllowThreads();
22907 result = ((wxSizeEvent const *)arg1)->GetRect();
22908 wxPyEndAllowThreads(__tstate);
22909 if (PyErr_Occurred()) SWIG_fail;
22910 }
22911 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22912 return resultobj;
22913 fail:
22914 return NULL;
22915 }
22916
22917
22918 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22919 PyObject *resultobj = 0;
22920 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22921 wxRect arg2 ;
22922 void *argp1 = 0 ;
22923 int res1 = 0 ;
22924 void *argp2 ;
22925 int res2 = 0 ;
22926 PyObject * obj0 = 0 ;
22927 PyObject * obj1 = 0 ;
22928 char * kwnames[] = {
22929 (char *) "self",(char *) "rect", NULL
22930 };
22931
22932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22934 if (!SWIG_IsOK(res1)) {
22935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22936 }
22937 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22938 {
22939 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
22940 if (!SWIG_IsOK(res2)) {
22941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22942 }
22943 if (!argp2) {
22944 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22945 } else {
22946 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
22947 arg2 = *temp;
22948 if (SWIG_IsNewObj(res2)) delete temp;
22949 }
22950 }
22951 {
22952 PyThreadState* __tstate = wxPyBeginAllowThreads();
22953 (arg1)->SetRect(arg2);
22954 wxPyEndAllowThreads(__tstate);
22955 if (PyErr_Occurred()) SWIG_fail;
22956 }
22957 resultobj = SWIG_Py_Void();
22958 return resultobj;
22959 fail:
22960 return NULL;
22961 }
22962
22963
22964 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22965 PyObject *resultobj = 0;
22966 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22967 wxSize arg2 ;
22968 void *argp1 = 0 ;
22969 int res1 = 0 ;
22970 void *argp2 ;
22971 int res2 = 0 ;
22972 PyObject * obj0 = 0 ;
22973 PyObject * obj1 = 0 ;
22974 char * kwnames[] = {
22975 (char *) "self",(char *) "size", NULL
22976 };
22977
22978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
22979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22980 if (!SWIG_IsOK(res1)) {
22981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22982 }
22983 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22984 {
22985 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
22986 if (!SWIG_IsOK(res2)) {
22987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22988 }
22989 if (!argp2) {
22990 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22991 } else {
22992 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
22993 arg2 = *temp;
22994 if (SWIG_IsNewObj(res2)) delete temp;
22995 }
22996 }
22997 {
22998 PyThreadState* __tstate = wxPyBeginAllowThreads();
22999 wxSizeEvent_SetSize(arg1,arg2);
23000 wxPyEndAllowThreads(__tstate);
23001 if (PyErr_Occurred()) SWIG_fail;
23002 }
23003 resultobj = SWIG_Py_Void();
23004 return resultobj;
23005 fail:
23006 return NULL;
23007 }
23008
23009
23010 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23011 PyObject *resultobj = 0;
23012 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23013 wxSize *arg2 = (wxSize *) 0 ;
23014 void *argp1 = 0 ;
23015 int res1 = 0 ;
23016 void *argp2 = 0 ;
23017 int res2 = 0 ;
23018 PyObject *swig_obj[2] ;
23019
23020 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23022 if (!SWIG_IsOK(res1)) {
23023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23024 }
23025 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23026 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23027 if (!SWIG_IsOK(res2)) {
23028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23029 }
23030 arg2 = reinterpret_cast< wxSize * >(argp2);
23031 if (arg1) (arg1)->m_size = *arg2;
23032
23033 resultobj = SWIG_Py_Void();
23034 return resultobj;
23035 fail:
23036 return NULL;
23037 }
23038
23039
23040 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23041 PyObject *resultobj = 0;
23042 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23043 wxSize *result = 0 ;
23044 void *argp1 = 0 ;
23045 int res1 = 0 ;
23046 PyObject *swig_obj[1] ;
23047
23048 if (!args) SWIG_fail;
23049 swig_obj[0] = args;
23050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23051 if (!SWIG_IsOK(res1)) {
23052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23053 }
23054 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23055 result = (wxSize *)& ((arg1)->m_size);
23056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23057 return resultobj;
23058 fail:
23059 return NULL;
23060 }
23061
23062
23063 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23064 PyObject *resultobj = 0;
23065 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23066 wxRect *arg2 = (wxRect *) 0 ;
23067 void *argp1 = 0 ;
23068 int res1 = 0 ;
23069 void *argp2 = 0 ;
23070 int res2 = 0 ;
23071 PyObject *swig_obj[2] ;
23072
23073 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23075 if (!SWIG_IsOK(res1)) {
23076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23077 }
23078 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23079 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23080 if (!SWIG_IsOK(res2)) {
23081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23082 }
23083 arg2 = reinterpret_cast< wxRect * >(argp2);
23084 if (arg1) (arg1)->m_rect = *arg2;
23085
23086 resultobj = SWIG_Py_Void();
23087 return resultobj;
23088 fail:
23089 return NULL;
23090 }
23091
23092
23093 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23094 PyObject *resultobj = 0;
23095 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23096 wxRect *result = 0 ;
23097 void *argp1 = 0 ;
23098 int res1 = 0 ;
23099 PyObject *swig_obj[1] ;
23100
23101 if (!args) SWIG_fail;
23102 swig_obj[0] = args;
23103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23104 if (!SWIG_IsOK(res1)) {
23105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23106 }
23107 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23108 result = (wxRect *)& ((arg1)->m_rect);
23109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23110 return resultobj;
23111 fail:
23112 return NULL;
23113 }
23114
23115
23116 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23117 PyObject *obj;
23118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23119 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23120 return SWIG_Py_Void();
23121 }
23122
23123 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23124 return SWIG_Python_InitShadowInstance(args);
23125 }
23126
23127 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23128 PyObject *resultobj = 0;
23129 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23130 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23131 int arg2 = (int) 0 ;
23132 wxMoveEvent *result = 0 ;
23133 wxPoint temp1 ;
23134 int val2 ;
23135 int ecode2 = 0 ;
23136 PyObject * obj0 = 0 ;
23137 PyObject * obj1 = 0 ;
23138 char * kwnames[] = {
23139 (char *) "pos",(char *) "winid", NULL
23140 };
23141
23142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23143 if (obj0) {
23144 {
23145 arg1 = &temp1;
23146 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23147 }
23148 }
23149 if (obj1) {
23150 ecode2 = SWIG_AsVal_int(obj1, &val2);
23151 if (!SWIG_IsOK(ecode2)) {
23152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23153 }
23154 arg2 = static_cast< int >(val2);
23155 }
23156 {
23157 PyThreadState* __tstate = wxPyBeginAllowThreads();
23158 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23159 wxPyEndAllowThreads(__tstate);
23160 if (PyErr_Occurred()) SWIG_fail;
23161 }
23162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23163 return resultobj;
23164 fail:
23165 return NULL;
23166 }
23167
23168
23169 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23170 PyObject *resultobj = 0;
23171 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23172 wxPoint result;
23173 void *argp1 = 0 ;
23174 int res1 = 0 ;
23175 PyObject *swig_obj[1] ;
23176
23177 if (!args) SWIG_fail;
23178 swig_obj[0] = args;
23179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23180 if (!SWIG_IsOK(res1)) {
23181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23182 }
23183 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23184 {
23185 PyThreadState* __tstate = wxPyBeginAllowThreads();
23186 result = ((wxMoveEvent const *)arg1)->GetPosition();
23187 wxPyEndAllowThreads(__tstate);
23188 if (PyErr_Occurred()) SWIG_fail;
23189 }
23190 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23191 return resultobj;
23192 fail:
23193 return NULL;
23194 }
23195
23196
23197 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23198 PyObject *resultobj = 0;
23199 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23200 wxRect result;
23201 void *argp1 = 0 ;
23202 int res1 = 0 ;
23203 PyObject *swig_obj[1] ;
23204
23205 if (!args) SWIG_fail;
23206 swig_obj[0] = args;
23207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23208 if (!SWIG_IsOK(res1)) {
23209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23210 }
23211 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23212 {
23213 PyThreadState* __tstate = wxPyBeginAllowThreads();
23214 result = ((wxMoveEvent const *)arg1)->GetRect();
23215 wxPyEndAllowThreads(__tstate);
23216 if (PyErr_Occurred()) SWIG_fail;
23217 }
23218 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23219 return resultobj;
23220 fail:
23221 return NULL;
23222 }
23223
23224
23225 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23226 PyObject *resultobj = 0;
23227 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23228 wxRect *arg2 = 0 ;
23229 void *argp1 = 0 ;
23230 int res1 = 0 ;
23231 wxRect temp2 ;
23232 PyObject * obj0 = 0 ;
23233 PyObject * obj1 = 0 ;
23234 char * kwnames[] = {
23235 (char *) "self",(char *) "rect", NULL
23236 };
23237
23238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23240 if (!SWIG_IsOK(res1)) {
23241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23242 }
23243 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23244 {
23245 arg2 = &temp2;
23246 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23247 }
23248 {
23249 PyThreadState* __tstate = wxPyBeginAllowThreads();
23250 (arg1)->SetRect((wxRect const &)*arg2);
23251 wxPyEndAllowThreads(__tstate);
23252 if (PyErr_Occurred()) SWIG_fail;
23253 }
23254 resultobj = SWIG_Py_Void();
23255 return resultobj;
23256 fail:
23257 return NULL;
23258 }
23259
23260
23261 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23262 PyObject *resultobj = 0;
23263 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23264 wxPoint *arg2 = 0 ;
23265 void *argp1 = 0 ;
23266 int res1 = 0 ;
23267 wxPoint temp2 ;
23268 PyObject * obj0 = 0 ;
23269 PyObject * obj1 = 0 ;
23270 char * kwnames[] = {
23271 (char *) "self",(char *) "pos", NULL
23272 };
23273
23274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23276 if (!SWIG_IsOK(res1)) {
23277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23278 }
23279 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23280 {
23281 arg2 = &temp2;
23282 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23283 }
23284 {
23285 PyThreadState* __tstate = wxPyBeginAllowThreads();
23286 (arg1)->SetPosition((wxPoint const &)*arg2);
23287 wxPyEndAllowThreads(__tstate);
23288 if (PyErr_Occurred()) SWIG_fail;
23289 }
23290 resultobj = SWIG_Py_Void();
23291 return resultobj;
23292 fail:
23293 return NULL;
23294 }
23295
23296
23297 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23298 PyObject *obj;
23299 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23300 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23301 return SWIG_Py_Void();
23302 }
23303
23304 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23305 return SWIG_Python_InitShadowInstance(args);
23306 }
23307
23308 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23309 PyObject *resultobj = 0;
23310 int arg1 = (int) 0 ;
23311 wxPaintEvent *result = 0 ;
23312 int val1 ;
23313 int ecode1 = 0 ;
23314 PyObject * obj0 = 0 ;
23315 char * kwnames[] = {
23316 (char *) "Id", NULL
23317 };
23318
23319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23320 if (obj0) {
23321 ecode1 = SWIG_AsVal_int(obj0, &val1);
23322 if (!SWIG_IsOK(ecode1)) {
23323 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23324 }
23325 arg1 = static_cast< int >(val1);
23326 }
23327 {
23328 PyThreadState* __tstate = wxPyBeginAllowThreads();
23329 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23330 wxPyEndAllowThreads(__tstate);
23331 if (PyErr_Occurred()) SWIG_fail;
23332 }
23333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23334 return resultobj;
23335 fail:
23336 return NULL;
23337 }
23338
23339
23340 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23341 PyObject *obj;
23342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23343 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23344 return SWIG_Py_Void();
23345 }
23346
23347 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23348 return SWIG_Python_InitShadowInstance(args);
23349 }
23350
23351 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23352 PyObject *resultobj = 0;
23353 int arg1 = (int) 0 ;
23354 wxNcPaintEvent *result = 0 ;
23355 int val1 ;
23356 int ecode1 = 0 ;
23357 PyObject * obj0 = 0 ;
23358 char * kwnames[] = {
23359 (char *) "winid", NULL
23360 };
23361
23362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23363 if (obj0) {
23364 ecode1 = SWIG_AsVal_int(obj0, &val1);
23365 if (!SWIG_IsOK(ecode1)) {
23366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23367 }
23368 arg1 = static_cast< int >(val1);
23369 }
23370 {
23371 PyThreadState* __tstate = wxPyBeginAllowThreads();
23372 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23373 wxPyEndAllowThreads(__tstate);
23374 if (PyErr_Occurred()) SWIG_fail;
23375 }
23376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23377 return resultobj;
23378 fail:
23379 return NULL;
23380 }
23381
23382
23383 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23384 PyObject *obj;
23385 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23386 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23387 return SWIG_Py_Void();
23388 }
23389
23390 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23391 return SWIG_Python_InitShadowInstance(args);
23392 }
23393
23394 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23395 PyObject *resultobj = 0;
23396 int arg1 = (int) 0 ;
23397 wxDC *arg2 = (wxDC *) NULL ;
23398 wxEraseEvent *result = 0 ;
23399 int val1 ;
23400 int ecode1 = 0 ;
23401 void *argp2 = 0 ;
23402 int res2 = 0 ;
23403 PyObject * obj0 = 0 ;
23404 PyObject * obj1 = 0 ;
23405 char * kwnames[] = {
23406 (char *) "Id",(char *) "dc", NULL
23407 };
23408
23409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23410 if (obj0) {
23411 ecode1 = SWIG_AsVal_int(obj0, &val1);
23412 if (!SWIG_IsOK(ecode1)) {
23413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23414 }
23415 arg1 = static_cast< int >(val1);
23416 }
23417 if (obj1) {
23418 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23419 if (!SWIG_IsOK(res2)) {
23420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23421 }
23422 arg2 = reinterpret_cast< wxDC * >(argp2);
23423 }
23424 {
23425 PyThreadState* __tstate = wxPyBeginAllowThreads();
23426 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23427 wxPyEndAllowThreads(__tstate);
23428 if (PyErr_Occurred()) SWIG_fail;
23429 }
23430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23431 return resultobj;
23432 fail:
23433 return NULL;
23434 }
23435
23436
23437 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23438 PyObject *resultobj = 0;
23439 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23440 wxDC *result = 0 ;
23441 void *argp1 = 0 ;
23442 int res1 = 0 ;
23443 PyObject *swig_obj[1] ;
23444
23445 if (!args) SWIG_fail;
23446 swig_obj[0] = args;
23447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23448 if (!SWIG_IsOK(res1)) {
23449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23450 }
23451 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23452 {
23453 PyThreadState* __tstate = wxPyBeginAllowThreads();
23454 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23455 wxPyEndAllowThreads(__tstate);
23456 if (PyErr_Occurred()) SWIG_fail;
23457 }
23458 {
23459 resultobj = wxPyMake_wxObject(result, (bool)0);
23460 }
23461 return resultobj;
23462 fail:
23463 return NULL;
23464 }
23465
23466
23467 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23468 PyObject *obj;
23469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23470 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23471 return SWIG_Py_Void();
23472 }
23473
23474 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23475 return SWIG_Python_InitShadowInstance(args);
23476 }
23477
23478 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23479 PyObject *resultobj = 0;
23480 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23481 int arg2 = (int) 0 ;
23482 wxFocusEvent *result = 0 ;
23483 int val1 ;
23484 int ecode1 = 0 ;
23485 int val2 ;
23486 int ecode2 = 0 ;
23487 PyObject * obj0 = 0 ;
23488 PyObject * obj1 = 0 ;
23489 char * kwnames[] = {
23490 (char *) "type",(char *) "winid", NULL
23491 };
23492
23493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23494 if (obj0) {
23495 ecode1 = SWIG_AsVal_int(obj0, &val1);
23496 if (!SWIG_IsOK(ecode1)) {
23497 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23498 }
23499 arg1 = static_cast< wxEventType >(val1);
23500 }
23501 if (obj1) {
23502 ecode2 = SWIG_AsVal_int(obj1, &val2);
23503 if (!SWIG_IsOK(ecode2)) {
23504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23505 }
23506 arg2 = static_cast< int >(val2);
23507 }
23508 {
23509 PyThreadState* __tstate = wxPyBeginAllowThreads();
23510 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23511 wxPyEndAllowThreads(__tstate);
23512 if (PyErr_Occurred()) SWIG_fail;
23513 }
23514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23515 return resultobj;
23516 fail:
23517 return NULL;
23518 }
23519
23520
23521 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23522 PyObject *resultobj = 0;
23523 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23524 wxWindow *result = 0 ;
23525 void *argp1 = 0 ;
23526 int res1 = 0 ;
23527 PyObject *swig_obj[1] ;
23528
23529 if (!args) SWIG_fail;
23530 swig_obj[0] = args;
23531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23532 if (!SWIG_IsOK(res1)) {
23533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23534 }
23535 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23536 {
23537 PyThreadState* __tstate = wxPyBeginAllowThreads();
23538 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23539 wxPyEndAllowThreads(__tstate);
23540 if (PyErr_Occurred()) SWIG_fail;
23541 }
23542 {
23543 resultobj = wxPyMake_wxObject(result, (bool)0);
23544 }
23545 return resultobj;
23546 fail:
23547 return NULL;
23548 }
23549
23550
23551 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23552 PyObject *resultobj = 0;
23553 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23554 wxWindow *arg2 = (wxWindow *) 0 ;
23555 void *argp1 = 0 ;
23556 int res1 = 0 ;
23557 void *argp2 = 0 ;
23558 int res2 = 0 ;
23559 PyObject * obj0 = 0 ;
23560 PyObject * obj1 = 0 ;
23561 char * kwnames[] = {
23562 (char *) "self",(char *) "win", NULL
23563 };
23564
23565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23567 if (!SWIG_IsOK(res1)) {
23568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23569 }
23570 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23571 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23572 if (!SWIG_IsOK(res2)) {
23573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23574 }
23575 arg2 = reinterpret_cast< wxWindow * >(argp2);
23576 {
23577 PyThreadState* __tstate = wxPyBeginAllowThreads();
23578 (arg1)->SetWindow(arg2);
23579 wxPyEndAllowThreads(__tstate);
23580 if (PyErr_Occurred()) SWIG_fail;
23581 }
23582 resultobj = SWIG_Py_Void();
23583 return resultobj;
23584 fail:
23585 return NULL;
23586 }
23587
23588
23589 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23590 PyObject *obj;
23591 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23592 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23593 return SWIG_Py_Void();
23594 }
23595
23596 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23597 return SWIG_Python_InitShadowInstance(args);
23598 }
23599
23600 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23601 PyObject *resultobj = 0;
23602 wxWindow *arg1 = (wxWindow *) NULL ;
23603 wxChildFocusEvent *result = 0 ;
23604 void *argp1 = 0 ;
23605 int res1 = 0 ;
23606 PyObject * obj0 = 0 ;
23607 char * kwnames[] = {
23608 (char *) "win", NULL
23609 };
23610
23611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23612 if (obj0) {
23613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23614 if (!SWIG_IsOK(res1)) {
23615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23616 }
23617 arg1 = reinterpret_cast< wxWindow * >(argp1);
23618 }
23619 {
23620 PyThreadState* __tstate = wxPyBeginAllowThreads();
23621 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23622 wxPyEndAllowThreads(__tstate);
23623 if (PyErr_Occurred()) SWIG_fail;
23624 }
23625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23626 return resultobj;
23627 fail:
23628 return NULL;
23629 }
23630
23631
23632 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23633 PyObject *resultobj = 0;
23634 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23635 wxWindow *result = 0 ;
23636 void *argp1 = 0 ;
23637 int res1 = 0 ;
23638 PyObject *swig_obj[1] ;
23639
23640 if (!args) SWIG_fail;
23641 swig_obj[0] = args;
23642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23643 if (!SWIG_IsOK(res1)) {
23644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23645 }
23646 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23647 {
23648 PyThreadState* __tstate = wxPyBeginAllowThreads();
23649 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23650 wxPyEndAllowThreads(__tstate);
23651 if (PyErr_Occurred()) SWIG_fail;
23652 }
23653 {
23654 resultobj = wxPyMake_wxObject(result, (bool)0);
23655 }
23656 return resultobj;
23657 fail:
23658 return NULL;
23659 }
23660
23661
23662 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23663 PyObject *obj;
23664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23665 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23666 return SWIG_Py_Void();
23667 }
23668
23669 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23670 return SWIG_Python_InitShadowInstance(args);
23671 }
23672
23673 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23674 PyObject *resultobj = 0;
23675 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23676 bool arg2 = (bool) true ;
23677 int arg3 = (int) 0 ;
23678 wxActivateEvent *result = 0 ;
23679 int val1 ;
23680 int ecode1 = 0 ;
23681 bool val2 ;
23682 int ecode2 = 0 ;
23683 int val3 ;
23684 int ecode3 = 0 ;
23685 PyObject * obj0 = 0 ;
23686 PyObject * obj1 = 0 ;
23687 PyObject * obj2 = 0 ;
23688 char * kwnames[] = {
23689 (char *) "type",(char *) "active",(char *) "Id", NULL
23690 };
23691
23692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23693 if (obj0) {
23694 ecode1 = SWIG_AsVal_int(obj0, &val1);
23695 if (!SWIG_IsOK(ecode1)) {
23696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23697 }
23698 arg1 = static_cast< wxEventType >(val1);
23699 }
23700 if (obj1) {
23701 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23702 if (!SWIG_IsOK(ecode2)) {
23703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23704 }
23705 arg2 = static_cast< bool >(val2);
23706 }
23707 if (obj2) {
23708 ecode3 = SWIG_AsVal_int(obj2, &val3);
23709 if (!SWIG_IsOK(ecode3)) {
23710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23711 }
23712 arg3 = static_cast< int >(val3);
23713 }
23714 {
23715 PyThreadState* __tstate = wxPyBeginAllowThreads();
23716 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23717 wxPyEndAllowThreads(__tstate);
23718 if (PyErr_Occurred()) SWIG_fail;
23719 }
23720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23721 return resultobj;
23722 fail:
23723 return NULL;
23724 }
23725
23726
23727 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23728 PyObject *resultobj = 0;
23729 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23730 bool result;
23731 void *argp1 = 0 ;
23732 int res1 = 0 ;
23733 PyObject *swig_obj[1] ;
23734
23735 if (!args) SWIG_fail;
23736 swig_obj[0] = args;
23737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23738 if (!SWIG_IsOK(res1)) {
23739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23740 }
23741 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23742 {
23743 PyThreadState* __tstate = wxPyBeginAllowThreads();
23744 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23745 wxPyEndAllowThreads(__tstate);
23746 if (PyErr_Occurred()) SWIG_fail;
23747 }
23748 {
23749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23750 }
23751 return resultobj;
23752 fail:
23753 return NULL;
23754 }
23755
23756
23757 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23758 PyObject *obj;
23759 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23760 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23761 return SWIG_Py_Void();
23762 }
23763
23764 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23765 return SWIG_Python_InitShadowInstance(args);
23766 }
23767
23768 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23769 PyObject *resultobj = 0;
23770 int arg1 = (int) 0 ;
23771 wxInitDialogEvent *result = 0 ;
23772 int val1 ;
23773 int ecode1 = 0 ;
23774 PyObject * obj0 = 0 ;
23775 char * kwnames[] = {
23776 (char *) "Id", NULL
23777 };
23778
23779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23780 if (obj0) {
23781 ecode1 = SWIG_AsVal_int(obj0, &val1);
23782 if (!SWIG_IsOK(ecode1)) {
23783 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23784 }
23785 arg1 = static_cast< int >(val1);
23786 }
23787 {
23788 PyThreadState* __tstate = wxPyBeginAllowThreads();
23789 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23790 wxPyEndAllowThreads(__tstate);
23791 if (PyErr_Occurred()) SWIG_fail;
23792 }
23793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23794 return resultobj;
23795 fail:
23796 return NULL;
23797 }
23798
23799
23800 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23801 PyObject *obj;
23802 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23803 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23804 return SWIG_Py_Void();
23805 }
23806
23807 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23808 return SWIG_Python_InitShadowInstance(args);
23809 }
23810
23811 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23812 PyObject *resultobj = 0;
23813 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23814 int arg2 = (int) 0 ;
23815 wxMenu *arg3 = (wxMenu *) NULL ;
23816 wxMenuEvent *result = 0 ;
23817 int val1 ;
23818 int ecode1 = 0 ;
23819 int val2 ;
23820 int ecode2 = 0 ;
23821 void *argp3 = 0 ;
23822 int res3 = 0 ;
23823 PyObject * obj0 = 0 ;
23824 PyObject * obj1 = 0 ;
23825 PyObject * obj2 = 0 ;
23826 char * kwnames[] = {
23827 (char *) "type",(char *) "winid",(char *) "menu", NULL
23828 };
23829
23830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23831 if (obj0) {
23832 ecode1 = SWIG_AsVal_int(obj0, &val1);
23833 if (!SWIG_IsOK(ecode1)) {
23834 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23835 }
23836 arg1 = static_cast< wxEventType >(val1);
23837 }
23838 if (obj1) {
23839 ecode2 = SWIG_AsVal_int(obj1, &val2);
23840 if (!SWIG_IsOK(ecode2)) {
23841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23842 }
23843 arg2 = static_cast< int >(val2);
23844 }
23845 if (obj2) {
23846 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23847 if (!SWIG_IsOK(res3)) {
23848 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23849 }
23850 arg3 = reinterpret_cast< wxMenu * >(argp3);
23851 }
23852 {
23853 PyThreadState* __tstate = wxPyBeginAllowThreads();
23854 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23855 wxPyEndAllowThreads(__tstate);
23856 if (PyErr_Occurred()) SWIG_fail;
23857 }
23858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23859 return resultobj;
23860 fail:
23861 return NULL;
23862 }
23863
23864
23865 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23866 PyObject *resultobj = 0;
23867 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23868 int result;
23869 void *argp1 = 0 ;
23870 int res1 = 0 ;
23871 PyObject *swig_obj[1] ;
23872
23873 if (!args) SWIG_fail;
23874 swig_obj[0] = args;
23875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23876 if (!SWIG_IsOK(res1)) {
23877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23878 }
23879 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23880 {
23881 PyThreadState* __tstate = wxPyBeginAllowThreads();
23882 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23883 wxPyEndAllowThreads(__tstate);
23884 if (PyErr_Occurred()) SWIG_fail;
23885 }
23886 resultobj = SWIG_From_int(static_cast< int >(result));
23887 return resultobj;
23888 fail:
23889 return NULL;
23890 }
23891
23892
23893 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23894 PyObject *resultobj = 0;
23895 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23896 bool result;
23897 void *argp1 = 0 ;
23898 int res1 = 0 ;
23899 PyObject *swig_obj[1] ;
23900
23901 if (!args) SWIG_fail;
23902 swig_obj[0] = args;
23903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23904 if (!SWIG_IsOK(res1)) {
23905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23906 }
23907 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23908 {
23909 PyThreadState* __tstate = wxPyBeginAllowThreads();
23910 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23911 wxPyEndAllowThreads(__tstate);
23912 if (PyErr_Occurred()) SWIG_fail;
23913 }
23914 {
23915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23916 }
23917 return resultobj;
23918 fail:
23919 return NULL;
23920 }
23921
23922
23923 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23924 PyObject *resultobj = 0;
23925 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23926 wxMenu *result = 0 ;
23927 void *argp1 = 0 ;
23928 int res1 = 0 ;
23929 PyObject *swig_obj[1] ;
23930
23931 if (!args) SWIG_fail;
23932 swig_obj[0] = args;
23933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23934 if (!SWIG_IsOK(res1)) {
23935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23936 }
23937 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23938 {
23939 PyThreadState* __tstate = wxPyBeginAllowThreads();
23940 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
23941 wxPyEndAllowThreads(__tstate);
23942 if (PyErr_Occurred()) SWIG_fail;
23943 }
23944 {
23945 resultobj = wxPyMake_wxObject(result, (bool)0);
23946 }
23947 return resultobj;
23948 fail:
23949 return NULL;
23950 }
23951
23952
23953 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23954 PyObject *obj;
23955 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23956 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
23957 return SWIG_Py_Void();
23958 }
23959
23960 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23961 return SWIG_Python_InitShadowInstance(args);
23962 }
23963
23964 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23965 PyObject *resultobj = 0;
23966 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23967 int arg2 = (int) 0 ;
23968 wxCloseEvent *result = 0 ;
23969 int val1 ;
23970 int ecode1 = 0 ;
23971 int val2 ;
23972 int ecode2 = 0 ;
23973 PyObject * obj0 = 0 ;
23974 PyObject * obj1 = 0 ;
23975 char * kwnames[] = {
23976 (char *) "type",(char *) "winid", NULL
23977 };
23978
23979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23980 if (obj0) {
23981 ecode1 = SWIG_AsVal_int(obj0, &val1);
23982 if (!SWIG_IsOK(ecode1)) {
23983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23984 }
23985 arg1 = static_cast< wxEventType >(val1);
23986 }
23987 if (obj1) {
23988 ecode2 = SWIG_AsVal_int(obj1, &val2);
23989 if (!SWIG_IsOK(ecode2)) {
23990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
23991 }
23992 arg2 = static_cast< int >(val2);
23993 }
23994 {
23995 PyThreadState* __tstate = wxPyBeginAllowThreads();
23996 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
23997 wxPyEndAllowThreads(__tstate);
23998 if (PyErr_Occurred()) SWIG_fail;
23999 }
24000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24001 return resultobj;
24002 fail:
24003 return NULL;
24004 }
24005
24006
24007 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24008 PyObject *resultobj = 0;
24009 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24010 bool arg2 ;
24011 void *argp1 = 0 ;
24012 int res1 = 0 ;
24013 bool val2 ;
24014 int ecode2 = 0 ;
24015 PyObject * obj0 = 0 ;
24016 PyObject * obj1 = 0 ;
24017 char * kwnames[] = {
24018 (char *) "self",(char *) "logOff", NULL
24019 };
24020
24021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24023 if (!SWIG_IsOK(res1)) {
24024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24025 }
24026 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24027 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24028 if (!SWIG_IsOK(ecode2)) {
24029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24030 }
24031 arg2 = static_cast< bool >(val2);
24032 {
24033 PyThreadState* __tstate = wxPyBeginAllowThreads();
24034 (arg1)->SetLoggingOff(arg2);
24035 wxPyEndAllowThreads(__tstate);
24036 if (PyErr_Occurred()) SWIG_fail;
24037 }
24038 resultobj = SWIG_Py_Void();
24039 return resultobj;
24040 fail:
24041 return NULL;
24042 }
24043
24044
24045 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24046 PyObject *resultobj = 0;
24047 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24048 bool result;
24049 void *argp1 = 0 ;
24050 int res1 = 0 ;
24051 PyObject *swig_obj[1] ;
24052
24053 if (!args) SWIG_fail;
24054 swig_obj[0] = args;
24055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24056 if (!SWIG_IsOK(res1)) {
24057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24058 }
24059 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24060 {
24061 PyThreadState* __tstate = wxPyBeginAllowThreads();
24062 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24063 wxPyEndAllowThreads(__tstate);
24064 if (PyErr_Occurred()) SWIG_fail;
24065 }
24066 {
24067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24068 }
24069 return resultobj;
24070 fail:
24071 return NULL;
24072 }
24073
24074
24075 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24076 PyObject *resultobj = 0;
24077 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24078 bool arg2 = (bool) true ;
24079 void *argp1 = 0 ;
24080 int res1 = 0 ;
24081 bool val2 ;
24082 int ecode2 = 0 ;
24083 PyObject * obj0 = 0 ;
24084 PyObject * obj1 = 0 ;
24085 char * kwnames[] = {
24086 (char *) "self",(char *) "veto", NULL
24087 };
24088
24089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24091 if (!SWIG_IsOK(res1)) {
24092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24093 }
24094 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24095 if (obj1) {
24096 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24097 if (!SWIG_IsOK(ecode2)) {
24098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24099 }
24100 arg2 = static_cast< bool >(val2);
24101 }
24102 {
24103 PyThreadState* __tstate = wxPyBeginAllowThreads();
24104 (arg1)->Veto(arg2);
24105 wxPyEndAllowThreads(__tstate);
24106 if (PyErr_Occurred()) SWIG_fail;
24107 }
24108 resultobj = SWIG_Py_Void();
24109 return resultobj;
24110 fail:
24111 return NULL;
24112 }
24113
24114
24115 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24116 PyObject *resultobj = 0;
24117 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24118 bool result;
24119 void *argp1 = 0 ;
24120 int res1 = 0 ;
24121 PyObject *swig_obj[1] ;
24122
24123 if (!args) SWIG_fail;
24124 swig_obj[0] = args;
24125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24126 if (!SWIG_IsOK(res1)) {
24127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24128 }
24129 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24130 {
24131 PyThreadState* __tstate = wxPyBeginAllowThreads();
24132 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24133 wxPyEndAllowThreads(__tstate);
24134 if (PyErr_Occurred()) SWIG_fail;
24135 }
24136 {
24137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24138 }
24139 return resultobj;
24140 fail:
24141 return NULL;
24142 }
24143
24144
24145 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24146 PyObject *resultobj = 0;
24147 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24148 bool arg2 ;
24149 void *argp1 = 0 ;
24150 int res1 = 0 ;
24151 bool val2 ;
24152 int ecode2 = 0 ;
24153 PyObject * obj0 = 0 ;
24154 PyObject * obj1 = 0 ;
24155 char * kwnames[] = {
24156 (char *) "self",(char *) "canVeto", NULL
24157 };
24158
24159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24161 if (!SWIG_IsOK(res1)) {
24162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24163 }
24164 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24165 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24166 if (!SWIG_IsOK(ecode2)) {
24167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24168 }
24169 arg2 = static_cast< bool >(val2);
24170 {
24171 PyThreadState* __tstate = wxPyBeginAllowThreads();
24172 (arg1)->SetCanVeto(arg2);
24173 wxPyEndAllowThreads(__tstate);
24174 if (PyErr_Occurred()) SWIG_fail;
24175 }
24176 resultobj = SWIG_Py_Void();
24177 return resultobj;
24178 fail:
24179 return NULL;
24180 }
24181
24182
24183 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24184 PyObject *resultobj = 0;
24185 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24186 bool result;
24187 void *argp1 = 0 ;
24188 int res1 = 0 ;
24189 PyObject *swig_obj[1] ;
24190
24191 if (!args) SWIG_fail;
24192 swig_obj[0] = args;
24193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24194 if (!SWIG_IsOK(res1)) {
24195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24196 }
24197 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24198 {
24199 PyThreadState* __tstate = wxPyBeginAllowThreads();
24200 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24201 wxPyEndAllowThreads(__tstate);
24202 if (PyErr_Occurred()) SWIG_fail;
24203 }
24204 {
24205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24206 }
24207 return resultobj;
24208 fail:
24209 return NULL;
24210 }
24211
24212
24213 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24214 PyObject *obj;
24215 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24216 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24217 return SWIG_Py_Void();
24218 }
24219
24220 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24221 return SWIG_Python_InitShadowInstance(args);
24222 }
24223
24224 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24225 PyObject *resultobj = 0;
24226 int arg1 = (int) 0 ;
24227 bool arg2 = (bool) false ;
24228 wxShowEvent *result = 0 ;
24229 int val1 ;
24230 int ecode1 = 0 ;
24231 bool val2 ;
24232 int ecode2 = 0 ;
24233 PyObject * obj0 = 0 ;
24234 PyObject * obj1 = 0 ;
24235 char * kwnames[] = {
24236 (char *) "winid",(char *) "show", NULL
24237 };
24238
24239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24240 if (obj0) {
24241 ecode1 = SWIG_AsVal_int(obj0, &val1);
24242 if (!SWIG_IsOK(ecode1)) {
24243 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24244 }
24245 arg1 = static_cast< int >(val1);
24246 }
24247 if (obj1) {
24248 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24249 if (!SWIG_IsOK(ecode2)) {
24250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24251 }
24252 arg2 = static_cast< bool >(val2);
24253 }
24254 {
24255 PyThreadState* __tstate = wxPyBeginAllowThreads();
24256 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24257 wxPyEndAllowThreads(__tstate);
24258 if (PyErr_Occurred()) SWIG_fail;
24259 }
24260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24261 return resultobj;
24262 fail:
24263 return NULL;
24264 }
24265
24266
24267 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24268 PyObject *resultobj = 0;
24269 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24270 bool arg2 ;
24271 void *argp1 = 0 ;
24272 int res1 = 0 ;
24273 bool val2 ;
24274 int ecode2 = 0 ;
24275 PyObject * obj0 = 0 ;
24276 PyObject * obj1 = 0 ;
24277 char * kwnames[] = {
24278 (char *) "self",(char *) "show", NULL
24279 };
24280
24281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24283 if (!SWIG_IsOK(res1)) {
24284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24285 }
24286 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24287 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24288 if (!SWIG_IsOK(ecode2)) {
24289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24290 }
24291 arg2 = static_cast< bool >(val2);
24292 {
24293 PyThreadState* __tstate = wxPyBeginAllowThreads();
24294 (arg1)->SetShow(arg2);
24295 wxPyEndAllowThreads(__tstate);
24296 if (PyErr_Occurred()) SWIG_fail;
24297 }
24298 resultobj = SWIG_Py_Void();
24299 return resultobj;
24300 fail:
24301 return NULL;
24302 }
24303
24304
24305 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24306 PyObject *resultobj = 0;
24307 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24308 bool result;
24309 void *argp1 = 0 ;
24310 int res1 = 0 ;
24311 PyObject *swig_obj[1] ;
24312
24313 if (!args) SWIG_fail;
24314 swig_obj[0] = args;
24315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24316 if (!SWIG_IsOK(res1)) {
24317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24318 }
24319 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24320 {
24321 PyThreadState* __tstate = wxPyBeginAllowThreads();
24322 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24323 wxPyEndAllowThreads(__tstate);
24324 if (PyErr_Occurred()) SWIG_fail;
24325 }
24326 {
24327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24328 }
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24336 PyObject *obj;
24337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24338 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24339 return SWIG_Py_Void();
24340 }
24341
24342 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24343 return SWIG_Python_InitShadowInstance(args);
24344 }
24345
24346 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24347 PyObject *resultobj = 0;
24348 int arg1 = (int) 0 ;
24349 bool arg2 = (bool) true ;
24350 wxIconizeEvent *result = 0 ;
24351 int val1 ;
24352 int ecode1 = 0 ;
24353 bool val2 ;
24354 int ecode2 = 0 ;
24355 PyObject * obj0 = 0 ;
24356 PyObject * obj1 = 0 ;
24357 char * kwnames[] = {
24358 (char *) "id",(char *) "iconized", NULL
24359 };
24360
24361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24362 if (obj0) {
24363 ecode1 = SWIG_AsVal_int(obj0, &val1);
24364 if (!SWIG_IsOK(ecode1)) {
24365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24366 }
24367 arg1 = static_cast< int >(val1);
24368 }
24369 if (obj1) {
24370 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24371 if (!SWIG_IsOK(ecode2)) {
24372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24373 }
24374 arg2 = static_cast< bool >(val2);
24375 }
24376 {
24377 PyThreadState* __tstate = wxPyBeginAllowThreads();
24378 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24379 wxPyEndAllowThreads(__tstate);
24380 if (PyErr_Occurred()) SWIG_fail;
24381 }
24382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24383 return resultobj;
24384 fail:
24385 return NULL;
24386 }
24387
24388
24389 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24390 PyObject *resultobj = 0;
24391 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24392 bool result;
24393 void *argp1 = 0 ;
24394 int res1 = 0 ;
24395 PyObject *swig_obj[1] ;
24396
24397 if (!args) SWIG_fail;
24398 swig_obj[0] = args;
24399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24400 if (!SWIG_IsOK(res1)) {
24401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24402 }
24403 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24404 {
24405 PyThreadState* __tstate = wxPyBeginAllowThreads();
24406 result = (bool)(arg1)->Iconized();
24407 wxPyEndAllowThreads(__tstate);
24408 if (PyErr_Occurred()) SWIG_fail;
24409 }
24410 {
24411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24412 }
24413 return resultobj;
24414 fail:
24415 return NULL;
24416 }
24417
24418
24419 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24420 PyObject *obj;
24421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24422 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24423 return SWIG_Py_Void();
24424 }
24425
24426 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24427 return SWIG_Python_InitShadowInstance(args);
24428 }
24429
24430 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24431 PyObject *resultobj = 0;
24432 int arg1 = (int) 0 ;
24433 wxMaximizeEvent *result = 0 ;
24434 int val1 ;
24435 int ecode1 = 0 ;
24436 PyObject * obj0 = 0 ;
24437 char * kwnames[] = {
24438 (char *) "id", NULL
24439 };
24440
24441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24442 if (obj0) {
24443 ecode1 = SWIG_AsVal_int(obj0, &val1);
24444 if (!SWIG_IsOK(ecode1)) {
24445 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24446 }
24447 arg1 = static_cast< int >(val1);
24448 }
24449 {
24450 PyThreadState* __tstate = wxPyBeginAllowThreads();
24451 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24452 wxPyEndAllowThreads(__tstate);
24453 if (PyErr_Occurred()) SWIG_fail;
24454 }
24455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24456 return resultobj;
24457 fail:
24458 return NULL;
24459 }
24460
24461
24462 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24463 PyObject *obj;
24464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24465 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24466 return SWIG_Py_Void();
24467 }
24468
24469 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24470 return SWIG_Python_InitShadowInstance(args);
24471 }
24472
24473 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24474 PyObject *resultobj = 0;
24475 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24476 wxPoint result;
24477 void *argp1 = 0 ;
24478 int res1 = 0 ;
24479 PyObject *swig_obj[1] ;
24480
24481 if (!args) SWIG_fail;
24482 swig_obj[0] = args;
24483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24484 if (!SWIG_IsOK(res1)) {
24485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24486 }
24487 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24488 {
24489 PyThreadState* __tstate = wxPyBeginAllowThreads();
24490 result = (arg1)->GetPosition();
24491 wxPyEndAllowThreads(__tstate);
24492 if (PyErr_Occurred()) SWIG_fail;
24493 }
24494 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24495 return resultobj;
24496 fail:
24497 return NULL;
24498 }
24499
24500
24501 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24502 PyObject *resultobj = 0;
24503 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24504 int result;
24505 void *argp1 = 0 ;
24506 int res1 = 0 ;
24507 PyObject *swig_obj[1] ;
24508
24509 if (!args) SWIG_fail;
24510 swig_obj[0] = args;
24511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24512 if (!SWIG_IsOK(res1)) {
24513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24514 }
24515 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24516 {
24517 PyThreadState* __tstate = wxPyBeginAllowThreads();
24518 result = (int)(arg1)->GetNumberOfFiles();
24519 wxPyEndAllowThreads(__tstate);
24520 if (PyErr_Occurred()) SWIG_fail;
24521 }
24522 resultobj = SWIG_From_int(static_cast< int >(result));
24523 return resultobj;
24524 fail:
24525 return NULL;
24526 }
24527
24528
24529 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24530 PyObject *resultobj = 0;
24531 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24532 PyObject *result = 0 ;
24533 void *argp1 = 0 ;
24534 int res1 = 0 ;
24535 PyObject *swig_obj[1] ;
24536
24537 if (!args) SWIG_fail;
24538 swig_obj[0] = args;
24539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24540 if (!SWIG_IsOK(res1)) {
24541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24542 }
24543 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24544 {
24545 PyThreadState* __tstate = wxPyBeginAllowThreads();
24546 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24547 wxPyEndAllowThreads(__tstate);
24548 if (PyErr_Occurred()) SWIG_fail;
24549 }
24550 resultobj = result;
24551 return resultobj;
24552 fail:
24553 return NULL;
24554 }
24555
24556
24557 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24558 PyObject *obj;
24559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24560 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24561 return SWIG_Py_Void();
24562 }
24563
24564 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24565 PyObject *resultobj = 0;
24566 int arg1 = (int) 0 ;
24567 wxUpdateUIEvent *result = 0 ;
24568 int val1 ;
24569 int ecode1 = 0 ;
24570 PyObject * obj0 = 0 ;
24571 char * kwnames[] = {
24572 (char *) "commandId", NULL
24573 };
24574
24575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24576 if (obj0) {
24577 ecode1 = SWIG_AsVal_int(obj0, &val1);
24578 if (!SWIG_IsOK(ecode1)) {
24579 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24580 }
24581 arg1 = static_cast< int >(val1);
24582 }
24583 {
24584 PyThreadState* __tstate = wxPyBeginAllowThreads();
24585 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24586 wxPyEndAllowThreads(__tstate);
24587 if (PyErr_Occurred()) SWIG_fail;
24588 }
24589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24590 return resultobj;
24591 fail:
24592 return NULL;
24593 }
24594
24595
24596 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24597 PyObject *resultobj = 0;
24598 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24599 bool result;
24600 void *argp1 = 0 ;
24601 int res1 = 0 ;
24602 PyObject *swig_obj[1] ;
24603
24604 if (!args) SWIG_fail;
24605 swig_obj[0] = args;
24606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24607 if (!SWIG_IsOK(res1)) {
24608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24609 }
24610 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24611 {
24612 PyThreadState* __tstate = wxPyBeginAllowThreads();
24613 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24614 wxPyEndAllowThreads(__tstate);
24615 if (PyErr_Occurred()) SWIG_fail;
24616 }
24617 {
24618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24619 }
24620 return resultobj;
24621 fail:
24622 return NULL;
24623 }
24624
24625
24626 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24627 PyObject *resultobj = 0;
24628 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24629 bool result;
24630 void *argp1 = 0 ;
24631 int res1 = 0 ;
24632 PyObject *swig_obj[1] ;
24633
24634 if (!args) SWIG_fail;
24635 swig_obj[0] = args;
24636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24637 if (!SWIG_IsOK(res1)) {
24638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24639 }
24640 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24641 {
24642 PyThreadState* __tstate = wxPyBeginAllowThreads();
24643 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24644 wxPyEndAllowThreads(__tstate);
24645 if (PyErr_Occurred()) SWIG_fail;
24646 }
24647 {
24648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24649 }
24650 return resultobj;
24651 fail:
24652 return NULL;
24653 }
24654
24655
24656 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24657 PyObject *resultobj = 0;
24658 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24659 bool result;
24660 void *argp1 = 0 ;
24661 int res1 = 0 ;
24662 PyObject *swig_obj[1] ;
24663
24664 if (!args) SWIG_fail;
24665 swig_obj[0] = args;
24666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24667 if (!SWIG_IsOK(res1)) {
24668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24669 }
24670 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24671 {
24672 PyThreadState* __tstate = wxPyBeginAllowThreads();
24673 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24674 wxPyEndAllowThreads(__tstate);
24675 if (PyErr_Occurred()) SWIG_fail;
24676 }
24677 {
24678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24679 }
24680 return resultobj;
24681 fail:
24682 return NULL;
24683 }
24684
24685
24686 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24687 PyObject *resultobj = 0;
24688 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24689 wxString result;
24690 void *argp1 = 0 ;
24691 int res1 = 0 ;
24692 PyObject *swig_obj[1] ;
24693
24694 if (!args) SWIG_fail;
24695 swig_obj[0] = args;
24696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24697 if (!SWIG_IsOK(res1)) {
24698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24699 }
24700 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24701 {
24702 PyThreadState* __tstate = wxPyBeginAllowThreads();
24703 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24704 wxPyEndAllowThreads(__tstate);
24705 if (PyErr_Occurred()) SWIG_fail;
24706 }
24707 {
24708 #if wxUSE_UNICODE
24709 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24710 #else
24711 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24712 #endif
24713 }
24714 return resultobj;
24715 fail:
24716 return NULL;
24717 }
24718
24719
24720 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24721 PyObject *resultobj = 0;
24722 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24723 bool result;
24724 void *argp1 = 0 ;
24725 int res1 = 0 ;
24726 PyObject *swig_obj[1] ;
24727
24728 if (!args) SWIG_fail;
24729 swig_obj[0] = args;
24730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24731 if (!SWIG_IsOK(res1)) {
24732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24733 }
24734 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24735 {
24736 PyThreadState* __tstate = wxPyBeginAllowThreads();
24737 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24738 wxPyEndAllowThreads(__tstate);
24739 if (PyErr_Occurred()) SWIG_fail;
24740 }
24741 {
24742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24743 }
24744 return resultobj;
24745 fail:
24746 return NULL;
24747 }
24748
24749
24750 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24751 PyObject *resultobj = 0;
24752 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24753 bool result;
24754 void *argp1 = 0 ;
24755 int res1 = 0 ;
24756 PyObject *swig_obj[1] ;
24757
24758 if (!args) SWIG_fail;
24759 swig_obj[0] = args;
24760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24761 if (!SWIG_IsOK(res1)) {
24762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24763 }
24764 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24765 {
24766 PyThreadState* __tstate = wxPyBeginAllowThreads();
24767 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24768 wxPyEndAllowThreads(__tstate);
24769 if (PyErr_Occurred()) SWIG_fail;
24770 }
24771 {
24772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24773 }
24774 return resultobj;
24775 fail:
24776 return NULL;
24777 }
24778
24779
24780 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24781 PyObject *resultobj = 0;
24782 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24783 bool result;
24784 void *argp1 = 0 ;
24785 int res1 = 0 ;
24786 PyObject *swig_obj[1] ;
24787
24788 if (!args) SWIG_fail;
24789 swig_obj[0] = args;
24790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24791 if (!SWIG_IsOK(res1)) {
24792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24793 }
24794 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24795 {
24796 PyThreadState* __tstate = wxPyBeginAllowThreads();
24797 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24798 wxPyEndAllowThreads(__tstate);
24799 if (PyErr_Occurred()) SWIG_fail;
24800 }
24801 {
24802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24803 }
24804 return resultobj;
24805 fail:
24806 return NULL;
24807 }
24808
24809
24810 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24811 PyObject *resultobj = 0;
24812 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24813 bool result;
24814 void *argp1 = 0 ;
24815 int res1 = 0 ;
24816 PyObject *swig_obj[1] ;
24817
24818 if (!args) SWIG_fail;
24819 swig_obj[0] = args;
24820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24821 if (!SWIG_IsOK(res1)) {
24822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24823 }
24824 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24825 {
24826 PyThreadState* __tstate = wxPyBeginAllowThreads();
24827 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24828 wxPyEndAllowThreads(__tstate);
24829 if (PyErr_Occurred()) SWIG_fail;
24830 }
24831 {
24832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24833 }
24834 return resultobj;
24835 fail:
24836 return NULL;
24837 }
24838
24839
24840 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24841 PyObject *resultobj = 0;
24842 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24843 bool arg2 ;
24844 void *argp1 = 0 ;
24845 int res1 = 0 ;
24846 bool val2 ;
24847 int ecode2 = 0 ;
24848 PyObject * obj0 = 0 ;
24849 PyObject * obj1 = 0 ;
24850 char * kwnames[] = {
24851 (char *) "self",(char *) "check", NULL
24852 };
24853
24854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24856 if (!SWIG_IsOK(res1)) {
24857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24858 }
24859 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24860 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24861 if (!SWIG_IsOK(ecode2)) {
24862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24863 }
24864 arg2 = static_cast< bool >(val2);
24865 {
24866 PyThreadState* __tstate = wxPyBeginAllowThreads();
24867 (arg1)->Check(arg2);
24868 wxPyEndAllowThreads(__tstate);
24869 if (PyErr_Occurred()) SWIG_fail;
24870 }
24871 resultobj = SWIG_Py_Void();
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24879 PyObject *resultobj = 0;
24880 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24881 bool arg2 ;
24882 void *argp1 = 0 ;
24883 int res1 = 0 ;
24884 bool val2 ;
24885 int ecode2 = 0 ;
24886 PyObject * obj0 = 0 ;
24887 PyObject * obj1 = 0 ;
24888 char * kwnames[] = {
24889 (char *) "self",(char *) "enable", NULL
24890 };
24891
24892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24894 if (!SWIG_IsOK(res1)) {
24895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24896 }
24897 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24898 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24899 if (!SWIG_IsOK(ecode2)) {
24900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24901 }
24902 arg2 = static_cast< bool >(val2);
24903 {
24904 PyThreadState* __tstate = wxPyBeginAllowThreads();
24905 (arg1)->Enable(arg2);
24906 wxPyEndAllowThreads(__tstate);
24907 if (PyErr_Occurred()) SWIG_fail;
24908 }
24909 resultobj = SWIG_Py_Void();
24910 return resultobj;
24911 fail:
24912 return NULL;
24913 }
24914
24915
24916 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24917 PyObject *resultobj = 0;
24918 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24919 bool arg2 ;
24920 void *argp1 = 0 ;
24921 int res1 = 0 ;
24922 bool val2 ;
24923 int ecode2 = 0 ;
24924 PyObject * obj0 = 0 ;
24925 PyObject * obj1 = 0 ;
24926 char * kwnames[] = {
24927 (char *) "self",(char *) "show", NULL
24928 };
24929
24930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24932 if (!SWIG_IsOK(res1)) {
24933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24934 }
24935 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24936 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24937 if (!SWIG_IsOK(ecode2)) {
24938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
24939 }
24940 arg2 = static_cast< bool >(val2);
24941 {
24942 PyThreadState* __tstate = wxPyBeginAllowThreads();
24943 (arg1)->Show(arg2);
24944 wxPyEndAllowThreads(__tstate);
24945 if (PyErr_Occurred()) SWIG_fail;
24946 }
24947 resultobj = SWIG_Py_Void();
24948 return resultobj;
24949 fail:
24950 return NULL;
24951 }
24952
24953
24954 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24955 PyObject *resultobj = 0;
24956 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24957 wxString *arg2 = 0 ;
24958 void *argp1 = 0 ;
24959 int res1 = 0 ;
24960 bool temp2 = false ;
24961 PyObject * obj0 = 0 ;
24962 PyObject * obj1 = 0 ;
24963 char * kwnames[] = {
24964 (char *) "self",(char *) "text", NULL
24965 };
24966
24967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
24968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24969 if (!SWIG_IsOK(res1)) {
24970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24971 }
24972 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24973 {
24974 arg2 = wxString_in_helper(obj1);
24975 if (arg2 == NULL) SWIG_fail;
24976 temp2 = true;
24977 }
24978 {
24979 PyThreadState* __tstate = wxPyBeginAllowThreads();
24980 (arg1)->SetText((wxString const &)*arg2);
24981 wxPyEndAllowThreads(__tstate);
24982 if (PyErr_Occurred()) SWIG_fail;
24983 }
24984 resultobj = SWIG_Py_Void();
24985 {
24986 if (temp2)
24987 delete arg2;
24988 }
24989 return resultobj;
24990 fail:
24991 {
24992 if (temp2)
24993 delete arg2;
24994 }
24995 return NULL;
24996 }
24997
24998
24999 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25000 PyObject *resultobj = 0;
25001 long arg1 ;
25002 long val1 ;
25003 int ecode1 = 0 ;
25004 PyObject * obj0 = 0 ;
25005 char * kwnames[] = {
25006 (char *) "updateInterval", NULL
25007 };
25008
25009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25010 ecode1 = SWIG_AsVal_long(obj0, &val1);
25011 if (!SWIG_IsOK(ecode1)) {
25012 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25013 }
25014 arg1 = static_cast< long >(val1);
25015 {
25016 PyThreadState* __tstate = wxPyBeginAllowThreads();
25017 wxUpdateUIEvent::SetUpdateInterval(arg1);
25018 wxPyEndAllowThreads(__tstate);
25019 if (PyErr_Occurred()) SWIG_fail;
25020 }
25021 resultobj = SWIG_Py_Void();
25022 return resultobj;
25023 fail:
25024 return NULL;
25025 }
25026
25027
25028 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25029 PyObject *resultobj = 0;
25030 long result;
25031
25032 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25033 {
25034 PyThreadState* __tstate = wxPyBeginAllowThreads();
25035 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25036 wxPyEndAllowThreads(__tstate);
25037 if (PyErr_Occurred()) SWIG_fail;
25038 }
25039 resultobj = SWIG_From_long(static_cast< long >(result));
25040 return resultobj;
25041 fail:
25042 return NULL;
25043 }
25044
25045
25046 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25047 PyObject *resultobj = 0;
25048 wxWindow *arg1 = (wxWindow *) 0 ;
25049 bool result;
25050 void *argp1 = 0 ;
25051 int res1 = 0 ;
25052 PyObject * obj0 = 0 ;
25053 char * kwnames[] = {
25054 (char *) "win", NULL
25055 };
25056
25057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25059 if (!SWIG_IsOK(res1)) {
25060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25061 }
25062 arg1 = reinterpret_cast< wxWindow * >(argp1);
25063 {
25064 PyThreadState* __tstate = wxPyBeginAllowThreads();
25065 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25066 wxPyEndAllowThreads(__tstate);
25067 if (PyErr_Occurred()) SWIG_fail;
25068 }
25069 {
25070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25071 }
25072 return resultobj;
25073 fail:
25074 return NULL;
25075 }
25076
25077
25078 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25079 PyObject *resultobj = 0;
25080
25081 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25082 {
25083 PyThreadState* __tstate = wxPyBeginAllowThreads();
25084 wxUpdateUIEvent::ResetUpdateTime();
25085 wxPyEndAllowThreads(__tstate);
25086 if (PyErr_Occurred()) SWIG_fail;
25087 }
25088 resultobj = SWIG_Py_Void();
25089 return resultobj;
25090 fail:
25091 return NULL;
25092 }
25093
25094
25095 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25096 PyObject *resultobj = 0;
25097 wxUpdateUIMode arg1 ;
25098 int val1 ;
25099 int ecode1 = 0 ;
25100 PyObject * obj0 = 0 ;
25101 char * kwnames[] = {
25102 (char *) "mode", NULL
25103 };
25104
25105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25106 ecode1 = SWIG_AsVal_int(obj0, &val1);
25107 if (!SWIG_IsOK(ecode1)) {
25108 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25109 }
25110 arg1 = static_cast< wxUpdateUIMode >(val1);
25111 {
25112 PyThreadState* __tstate = wxPyBeginAllowThreads();
25113 wxUpdateUIEvent::SetMode(arg1);
25114 wxPyEndAllowThreads(__tstate);
25115 if (PyErr_Occurred()) SWIG_fail;
25116 }
25117 resultobj = SWIG_Py_Void();
25118 return resultobj;
25119 fail:
25120 return NULL;
25121 }
25122
25123
25124 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25125 PyObject *resultobj = 0;
25126 wxUpdateUIMode result;
25127
25128 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25129 {
25130 PyThreadState* __tstate = wxPyBeginAllowThreads();
25131 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25132 wxPyEndAllowThreads(__tstate);
25133 if (PyErr_Occurred()) SWIG_fail;
25134 }
25135 resultobj = SWIG_From_int(static_cast< int >(result));
25136 return resultobj;
25137 fail:
25138 return NULL;
25139 }
25140
25141
25142 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25143 PyObject *obj;
25144 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25145 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25146 return SWIG_Py_Void();
25147 }
25148
25149 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25150 return SWIG_Python_InitShadowInstance(args);
25151 }
25152
25153 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25154 PyObject *resultobj = 0;
25155 wxSysColourChangedEvent *result = 0 ;
25156
25157 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25158 {
25159 PyThreadState* __tstate = wxPyBeginAllowThreads();
25160 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25161 wxPyEndAllowThreads(__tstate);
25162 if (PyErr_Occurred()) SWIG_fail;
25163 }
25164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25165 return resultobj;
25166 fail:
25167 return NULL;
25168 }
25169
25170
25171 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25172 PyObject *obj;
25173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25174 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25175 return SWIG_Py_Void();
25176 }
25177
25178 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25179 return SWIG_Python_InitShadowInstance(args);
25180 }
25181
25182 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25183 PyObject *resultobj = 0;
25184 int arg1 = (int) 0 ;
25185 wxWindow *arg2 = (wxWindow *) NULL ;
25186 wxMouseCaptureChangedEvent *result = 0 ;
25187 int val1 ;
25188 int ecode1 = 0 ;
25189 void *argp2 = 0 ;
25190 int res2 = 0 ;
25191 PyObject * obj0 = 0 ;
25192 PyObject * obj1 = 0 ;
25193 char * kwnames[] = {
25194 (char *) "winid",(char *) "gainedCapture", NULL
25195 };
25196
25197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25198 if (obj0) {
25199 ecode1 = SWIG_AsVal_int(obj0, &val1);
25200 if (!SWIG_IsOK(ecode1)) {
25201 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25202 }
25203 arg1 = static_cast< int >(val1);
25204 }
25205 if (obj1) {
25206 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25207 if (!SWIG_IsOK(res2)) {
25208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25209 }
25210 arg2 = reinterpret_cast< wxWindow * >(argp2);
25211 }
25212 {
25213 PyThreadState* __tstate = wxPyBeginAllowThreads();
25214 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25215 wxPyEndAllowThreads(__tstate);
25216 if (PyErr_Occurred()) SWIG_fail;
25217 }
25218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25219 return resultobj;
25220 fail:
25221 return NULL;
25222 }
25223
25224
25225 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25226 PyObject *resultobj = 0;
25227 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25228 wxWindow *result = 0 ;
25229 void *argp1 = 0 ;
25230 int res1 = 0 ;
25231 PyObject *swig_obj[1] ;
25232
25233 if (!args) SWIG_fail;
25234 swig_obj[0] = args;
25235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25236 if (!SWIG_IsOK(res1)) {
25237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25238 }
25239 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25240 {
25241 PyThreadState* __tstate = wxPyBeginAllowThreads();
25242 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25243 wxPyEndAllowThreads(__tstate);
25244 if (PyErr_Occurred()) SWIG_fail;
25245 }
25246 {
25247 resultobj = wxPyMake_wxObject(result, (bool)0);
25248 }
25249 return resultobj;
25250 fail:
25251 return NULL;
25252 }
25253
25254
25255 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25256 PyObject *obj;
25257 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25258 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25259 return SWIG_Py_Void();
25260 }
25261
25262 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25263 return SWIG_Python_InitShadowInstance(args);
25264 }
25265
25266 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25267 PyObject *resultobj = 0;
25268 wxDisplayChangedEvent *result = 0 ;
25269
25270 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25271 {
25272 PyThreadState* __tstate = wxPyBeginAllowThreads();
25273 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25274 wxPyEndAllowThreads(__tstate);
25275 if (PyErr_Occurred()) SWIG_fail;
25276 }
25277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25278 return resultobj;
25279 fail:
25280 return NULL;
25281 }
25282
25283
25284 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25285 PyObject *obj;
25286 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25287 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25288 return SWIG_Py_Void();
25289 }
25290
25291 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25292 return SWIG_Python_InitShadowInstance(args);
25293 }
25294
25295 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25296 PyObject *resultobj = 0;
25297 int arg1 = (int) 0 ;
25298 wxPaletteChangedEvent *result = 0 ;
25299 int val1 ;
25300 int ecode1 = 0 ;
25301 PyObject * obj0 = 0 ;
25302 char * kwnames[] = {
25303 (char *) "id", NULL
25304 };
25305
25306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25307 if (obj0) {
25308 ecode1 = SWIG_AsVal_int(obj0, &val1);
25309 if (!SWIG_IsOK(ecode1)) {
25310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25311 }
25312 arg1 = static_cast< int >(val1);
25313 }
25314 {
25315 PyThreadState* __tstate = wxPyBeginAllowThreads();
25316 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25317 wxPyEndAllowThreads(__tstate);
25318 if (PyErr_Occurred()) SWIG_fail;
25319 }
25320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25321 return resultobj;
25322 fail:
25323 return NULL;
25324 }
25325
25326
25327 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25328 PyObject *resultobj = 0;
25329 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25330 wxWindow *arg2 = (wxWindow *) 0 ;
25331 void *argp1 = 0 ;
25332 int res1 = 0 ;
25333 void *argp2 = 0 ;
25334 int res2 = 0 ;
25335 PyObject * obj0 = 0 ;
25336 PyObject * obj1 = 0 ;
25337 char * kwnames[] = {
25338 (char *) "self",(char *) "win", NULL
25339 };
25340
25341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25343 if (!SWIG_IsOK(res1)) {
25344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25345 }
25346 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25347 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25348 if (!SWIG_IsOK(res2)) {
25349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25350 }
25351 arg2 = reinterpret_cast< wxWindow * >(argp2);
25352 {
25353 PyThreadState* __tstate = wxPyBeginAllowThreads();
25354 (arg1)->SetChangedWindow(arg2);
25355 wxPyEndAllowThreads(__tstate);
25356 if (PyErr_Occurred()) SWIG_fail;
25357 }
25358 resultobj = SWIG_Py_Void();
25359 return resultobj;
25360 fail:
25361 return NULL;
25362 }
25363
25364
25365 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25366 PyObject *resultobj = 0;
25367 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25368 wxWindow *result = 0 ;
25369 void *argp1 = 0 ;
25370 int res1 = 0 ;
25371 PyObject *swig_obj[1] ;
25372
25373 if (!args) SWIG_fail;
25374 swig_obj[0] = args;
25375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25376 if (!SWIG_IsOK(res1)) {
25377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25378 }
25379 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25380 {
25381 PyThreadState* __tstate = wxPyBeginAllowThreads();
25382 result = (wxWindow *)(arg1)->GetChangedWindow();
25383 wxPyEndAllowThreads(__tstate);
25384 if (PyErr_Occurred()) SWIG_fail;
25385 }
25386 {
25387 resultobj = wxPyMake_wxObject(result, (bool)0);
25388 }
25389 return resultobj;
25390 fail:
25391 return NULL;
25392 }
25393
25394
25395 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25396 PyObject *obj;
25397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25398 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25399 return SWIG_Py_Void();
25400 }
25401
25402 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25403 return SWIG_Python_InitShadowInstance(args);
25404 }
25405
25406 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25407 PyObject *resultobj = 0;
25408 int arg1 = (int) 0 ;
25409 wxQueryNewPaletteEvent *result = 0 ;
25410 int val1 ;
25411 int ecode1 = 0 ;
25412 PyObject * obj0 = 0 ;
25413 char * kwnames[] = {
25414 (char *) "winid", NULL
25415 };
25416
25417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25418 if (obj0) {
25419 ecode1 = SWIG_AsVal_int(obj0, &val1);
25420 if (!SWIG_IsOK(ecode1)) {
25421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25422 }
25423 arg1 = static_cast< int >(val1);
25424 }
25425 {
25426 PyThreadState* __tstate = wxPyBeginAllowThreads();
25427 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25428 wxPyEndAllowThreads(__tstate);
25429 if (PyErr_Occurred()) SWIG_fail;
25430 }
25431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25432 return resultobj;
25433 fail:
25434 return NULL;
25435 }
25436
25437
25438 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25439 PyObject *resultobj = 0;
25440 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25441 bool arg2 ;
25442 void *argp1 = 0 ;
25443 int res1 = 0 ;
25444 bool val2 ;
25445 int ecode2 = 0 ;
25446 PyObject * obj0 = 0 ;
25447 PyObject * obj1 = 0 ;
25448 char * kwnames[] = {
25449 (char *) "self",(char *) "realized", NULL
25450 };
25451
25452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25454 if (!SWIG_IsOK(res1)) {
25455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25456 }
25457 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25458 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25459 if (!SWIG_IsOK(ecode2)) {
25460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25461 }
25462 arg2 = static_cast< bool >(val2);
25463 {
25464 PyThreadState* __tstate = wxPyBeginAllowThreads();
25465 (arg1)->SetPaletteRealized(arg2);
25466 wxPyEndAllowThreads(__tstate);
25467 if (PyErr_Occurred()) SWIG_fail;
25468 }
25469 resultobj = SWIG_Py_Void();
25470 return resultobj;
25471 fail:
25472 return NULL;
25473 }
25474
25475
25476 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25477 PyObject *resultobj = 0;
25478 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25479 bool result;
25480 void *argp1 = 0 ;
25481 int res1 = 0 ;
25482 PyObject *swig_obj[1] ;
25483
25484 if (!args) SWIG_fail;
25485 swig_obj[0] = args;
25486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25487 if (!SWIG_IsOK(res1)) {
25488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25489 }
25490 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25491 {
25492 PyThreadState* __tstate = wxPyBeginAllowThreads();
25493 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25494 wxPyEndAllowThreads(__tstate);
25495 if (PyErr_Occurred()) SWIG_fail;
25496 }
25497 {
25498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25499 }
25500 return resultobj;
25501 fail:
25502 return NULL;
25503 }
25504
25505
25506 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25507 PyObject *obj;
25508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25509 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25510 return SWIG_Py_Void();
25511 }
25512
25513 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25514 return SWIG_Python_InitShadowInstance(args);
25515 }
25516
25517 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25518 PyObject *resultobj = 0;
25519 wxNavigationKeyEvent *result = 0 ;
25520
25521 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25522 {
25523 PyThreadState* __tstate = wxPyBeginAllowThreads();
25524 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25525 wxPyEndAllowThreads(__tstate);
25526 if (PyErr_Occurred()) SWIG_fail;
25527 }
25528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25529 return resultobj;
25530 fail:
25531 return NULL;
25532 }
25533
25534
25535 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25536 PyObject *resultobj = 0;
25537 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25538 bool result;
25539 void *argp1 = 0 ;
25540 int res1 = 0 ;
25541 PyObject *swig_obj[1] ;
25542
25543 if (!args) SWIG_fail;
25544 swig_obj[0] = args;
25545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25546 if (!SWIG_IsOK(res1)) {
25547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25548 }
25549 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25550 {
25551 PyThreadState* __tstate = wxPyBeginAllowThreads();
25552 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25553 wxPyEndAllowThreads(__tstate);
25554 if (PyErr_Occurred()) SWIG_fail;
25555 }
25556 {
25557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25558 }
25559 return resultobj;
25560 fail:
25561 return NULL;
25562 }
25563
25564
25565 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25566 PyObject *resultobj = 0;
25567 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25568 bool arg2 ;
25569 void *argp1 = 0 ;
25570 int res1 = 0 ;
25571 bool val2 ;
25572 int ecode2 = 0 ;
25573 PyObject * obj0 = 0 ;
25574 PyObject * obj1 = 0 ;
25575 char * kwnames[] = {
25576 (char *) "self",(char *) "forward", NULL
25577 };
25578
25579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25581 if (!SWIG_IsOK(res1)) {
25582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25583 }
25584 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25585 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25586 if (!SWIG_IsOK(ecode2)) {
25587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25588 }
25589 arg2 = static_cast< bool >(val2);
25590 {
25591 PyThreadState* __tstate = wxPyBeginAllowThreads();
25592 (arg1)->SetDirection(arg2);
25593 wxPyEndAllowThreads(__tstate);
25594 if (PyErr_Occurred()) SWIG_fail;
25595 }
25596 resultobj = SWIG_Py_Void();
25597 return resultobj;
25598 fail:
25599 return NULL;
25600 }
25601
25602
25603 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25604 PyObject *resultobj = 0;
25605 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25606 bool result;
25607 void *argp1 = 0 ;
25608 int res1 = 0 ;
25609 PyObject *swig_obj[1] ;
25610
25611 if (!args) SWIG_fail;
25612 swig_obj[0] = args;
25613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25614 if (!SWIG_IsOK(res1)) {
25615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25616 }
25617 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25618 {
25619 PyThreadState* __tstate = wxPyBeginAllowThreads();
25620 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25621 wxPyEndAllowThreads(__tstate);
25622 if (PyErr_Occurred()) SWIG_fail;
25623 }
25624 {
25625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25626 }
25627 return resultobj;
25628 fail:
25629 return NULL;
25630 }
25631
25632
25633 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25634 PyObject *resultobj = 0;
25635 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25636 bool arg2 ;
25637 void *argp1 = 0 ;
25638 int res1 = 0 ;
25639 bool val2 ;
25640 int ecode2 = 0 ;
25641 PyObject * obj0 = 0 ;
25642 PyObject * obj1 = 0 ;
25643 char * kwnames[] = {
25644 (char *) "self",(char *) "ischange", NULL
25645 };
25646
25647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25649 if (!SWIG_IsOK(res1)) {
25650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25651 }
25652 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25653 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25654 if (!SWIG_IsOK(ecode2)) {
25655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25656 }
25657 arg2 = static_cast< bool >(val2);
25658 {
25659 PyThreadState* __tstate = wxPyBeginAllowThreads();
25660 (arg1)->SetWindowChange(arg2);
25661 wxPyEndAllowThreads(__tstate);
25662 if (PyErr_Occurred()) SWIG_fail;
25663 }
25664 resultobj = SWIG_Py_Void();
25665 return resultobj;
25666 fail:
25667 return NULL;
25668 }
25669
25670
25671 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25672 PyObject *resultobj = 0;
25673 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25674 bool result;
25675 void *argp1 = 0 ;
25676 int res1 = 0 ;
25677 PyObject *swig_obj[1] ;
25678
25679 if (!args) SWIG_fail;
25680 swig_obj[0] = args;
25681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25682 if (!SWIG_IsOK(res1)) {
25683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25684 }
25685 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25686 {
25687 PyThreadState* __tstate = wxPyBeginAllowThreads();
25688 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25689 wxPyEndAllowThreads(__tstate);
25690 if (PyErr_Occurred()) SWIG_fail;
25691 }
25692 {
25693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25694 }
25695 return resultobj;
25696 fail:
25697 return NULL;
25698 }
25699
25700
25701 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25702 PyObject *resultobj = 0;
25703 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25704 bool arg2 ;
25705 void *argp1 = 0 ;
25706 int res1 = 0 ;
25707 bool val2 ;
25708 int ecode2 = 0 ;
25709 PyObject * obj0 = 0 ;
25710 PyObject * obj1 = 0 ;
25711 char * kwnames[] = {
25712 (char *) "self",(char *) "bIs", NULL
25713 };
25714
25715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25717 if (!SWIG_IsOK(res1)) {
25718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25719 }
25720 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25721 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25722 if (!SWIG_IsOK(ecode2)) {
25723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25724 }
25725 arg2 = static_cast< bool >(val2);
25726 {
25727 PyThreadState* __tstate = wxPyBeginAllowThreads();
25728 (arg1)->SetFromTab(arg2);
25729 wxPyEndAllowThreads(__tstate);
25730 if (PyErr_Occurred()) SWIG_fail;
25731 }
25732 resultobj = SWIG_Py_Void();
25733 return resultobj;
25734 fail:
25735 return NULL;
25736 }
25737
25738
25739 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25740 PyObject *resultobj = 0;
25741 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25742 long arg2 ;
25743 void *argp1 = 0 ;
25744 int res1 = 0 ;
25745 long val2 ;
25746 int ecode2 = 0 ;
25747 PyObject * obj0 = 0 ;
25748 PyObject * obj1 = 0 ;
25749 char * kwnames[] = {
25750 (char *) "self",(char *) "flags", NULL
25751 };
25752
25753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25755 if (!SWIG_IsOK(res1)) {
25756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25757 }
25758 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25759 ecode2 = SWIG_AsVal_long(obj1, &val2);
25760 if (!SWIG_IsOK(ecode2)) {
25761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25762 }
25763 arg2 = static_cast< long >(val2);
25764 {
25765 PyThreadState* __tstate = wxPyBeginAllowThreads();
25766 (arg1)->SetFlags(arg2);
25767 wxPyEndAllowThreads(__tstate);
25768 if (PyErr_Occurred()) SWIG_fail;
25769 }
25770 resultobj = SWIG_Py_Void();
25771 return resultobj;
25772 fail:
25773 return NULL;
25774 }
25775
25776
25777 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25778 PyObject *resultobj = 0;
25779 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25780 wxWindow *result = 0 ;
25781 void *argp1 = 0 ;
25782 int res1 = 0 ;
25783 PyObject *swig_obj[1] ;
25784
25785 if (!args) SWIG_fail;
25786 swig_obj[0] = args;
25787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25788 if (!SWIG_IsOK(res1)) {
25789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25790 }
25791 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25792 {
25793 PyThreadState* __tstate = wxPyBeginAllowThreads();
25794 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25795 wxPyEndAllowThreads(__tstate);
25796 if (PyErr_Occurred()) SWIG_fail;
25797 }
25798 {
25799 resultobj = wxPyMake_wxObject(result, (bool)0);
25800 }
25801 return resultobj;
25802 fail:
25803 return NULL;
25804 }
25805
25806
25807 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25808 PyObject *resultobj = 0;
25809 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25810 wxWindow *arg2 = (wxWindow *) 0 ;
25811 void *argp1 = 0 ;
25812 int res1 = 0 ;
25813 void *argp2 = 0 ;
25814 int res2 = 0 ;
25815 PyObject * obj0 = 0 ;
25816 PyObject * obj1 = 0 ;
25817 char * kwnames[] = {
25818 (char *) "self",(char *) "win", NULL
25819 };
25820
25821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25823 if (!SWIG_IsOK(res1)) {
25824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25825 }
25826 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25827 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25828 if (!SWIG_IsOK(res2)) {
25829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25830 }
25831 arg2 = reinterpret_cast< wxWindow * >(argp2);
25832 {
25833 PyThreadState* __tstate = wxPyBeginAllowThreads();
25834 (arg1)->SetCurrentFocus(arg2);
25835 wxPyEndAllowThreads(__tstate);
25836 if (PyErr_Occurred()) SWIG_fail;
25837 }
25838 resultobj = SWIG_Py_Void();
25839 return resultobj;
25840 fail:
25841 return NULL;
25842 }
25843
25844
25845 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25846 PyObject *obj;
25847 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25848 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25849 return SWIG_Py_Void();
25850 }
25851
25852 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25853 return SWIG_Python_InitShadowInstance(args);
25854 }
25855
25856 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25857 PyObject *resultobj = 0;
25858 wxWindow *arg1 = (wxWindow *) NULL ;
25859 wxWindowCreateEvent *result = 0 ;
25860 void *argp1 = 0 ;
25861 int res1 = 0 ;
25862 PyObject * obj0 = 0 ;
25863 char * kwnames[] = {
25864 (char *) "win", NULL
25865 };
25866
25867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25868 if (obj0) {
25869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25870 if (!SWIG_IsOK(res1)) {
25871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25872 }
25873 arg1 = reinterpret_cast< wxWindow * >(argp1);
25874 }
25875 {
25876 PyThreadState* __tstate = wxPyBeginAllowThreads();
25877 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25878 wxPyEndAllowThreads(__tstate);
25879 if (PyErr_Occurred()) SWIG_fail;
25880 }
25881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25882 return resultobj;
25883 fail:
25884 return NULL;
25885 }
25886
25887
25888 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25889 PyObject *resultobj = 0;
25890 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25891 wxWindow *result = 0 ;
25892 void *argp1 = 0 ;
25893 int res1 = 0 ;
25894 PyObject *swig_obj[1] ;
25895
25896 if (!args) SWIG_fail;
25897 swig_obj[0] = args;
25898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25899 if (!SWIG_IsOK(res1)) {
25900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25901 }
25902 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25903 {
25904 PyThreadState* __tstate = wxPyBeginAllowThreads();
25905 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25906 wxPyEndAllowThreads(__tstate);
25907 if (PyErr_Occurred()) SWIG_fail;
25908 }
25909 {
25910 resultobj = wxPyMake_wxObject(result, (bool)0);
25911 }
25912 return resultobj;
25913 fail:
25914 return NULL;
25915 }
25916
25917
25918 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25919 PyObject *obj;
25920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25921 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25922 return SWIG_Py_Void();
25923 }
25924
25925 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25926 return SWIG_Python_InitShadowInstance(args);
25927 }
25928
25929 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25930 PyObject *resultobj = 0;
25931 wxWindow *arg1 = (wxWindow *) NULL ;
25932 wxWindowDestroyEvent *result = 0 ;
25933 void *argp1 = 0 ;
25934 int res1 = 0 ;
25935 PyObject * obj0 = 0 ;
25936 char * kwnames[] = {
25937 (char *) "win", NULL
25938 };
25939
25940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
25941 if (obj0) {
25942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25943 if (!SWIG_IsOK(res1)) {
25944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25945 }
25946 arg1 = reinterpret_cast< wxWindow * >(argp1);
25947 }
25948 {
25949 PyThreadState* __tstate = wxPyBeginAllowThreads();
25950 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
25951 wxPyEndAllowThreads(__tstate);
25952 if (PyErr_Occurred()) SWIG_fail;
25953 }
25954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
25955 return resultobj;
25956 fail:
25957 return NULL;
25958 }
25959
25960
25961 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25962 PyObject *resultobj = 0;
25963 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
25964 wxWindow *result = 0 ;
25965 void *argp1 = 0 ;
25966 int res1 = 0 ;
25967 PyObject *swig_obj[1] ;
25968
25969 if (!args) SWIG_fail;
25970 swig_obj[0] = args;
25971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
25972 if (!SWIG_IsOK(res1)) {
25973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
25974 }
25975 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
25976 {
25977 PyThreadState* __tstate = wxPyBeginAllowThreads();
25978 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
25979 wxPyEndAllowThreads(__tstate);
25980 if (PyErr_Occurred()) SWIG_fail;
25981 }
25982 {
25983 resultobj = wxPyMake_wxObject(result, (bool)0);
25984 }
25985 return resultobj;
25986 fail:
25987 return NULL;
25988 }
25989
25990
25991 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25992 PyObject *obj;
25993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25994 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
25995 return SWIG_Py_Void();
25996 }
25997
25998 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25999 return SWIG_Python_InitShadowInstance(args);
26000 }
26001
26002 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26003 PyObject *resultobj = 0;
26004 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26005 int arg2 = (int) 0 ;
26006 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26007 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26008 wxContextMenuEvent *result = 0 ;
26009 int val1 ;
26010 int ecode1 = 0 ;
26011 int val2 ;
26012 int ecode2 = 0 ;
26013 wxPoint temp3 ;
26014 PyObject * obj0 = 0 ;
26015 PyObject * obj1 = 0 ;
26016 PyObject * obj2 = 0 ;
26017 char * kwnames[] = {
26018 (char *) "type",(char *) "winid",(char *) "pt", NULL
26019 };
26020
26021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26022 if (obj0) {
26023 ecode1 = SWIG_AsVal_int(obj0, &val1);
26024 if (!SWIG_IsOK(ecode1)) {
26025 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26026 }
26027 arg1 = static_cast< wxEventType >(val1);
26028 }
26029 if (obj1) {
26030 ecode2 = SWIG_AsVal_int(obj1, &val2);
26031 if (!SWIG_IsOK(ecode2)) {
26032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26033 }
26034 arg2 = static_cast< int >(val2);
26035 }
26036 if (obj2) {
26037 {
26038 arg3 = &temp3;
26039 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26040 }
26041 }
26042 {
26043 PyThreadState* __tstate = wxPyBeginAllowThreads();
26044 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26045 wxPyEndAllowThreads(__tstate);
26046 if (PyErr_Occurred()) SWIG_fail;
26047 }
26048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26049 return resultobj;
26050 fail:
26051 return NULL;
26052 }
26053
26054
26055 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26056 PyObject *resultobj = 0;
26057 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26058 wxPoint *result = 0 ;
26059 void *argp1 = 0 ;
26060 int res1 = 0 ;
26061 PyObject *swig_obj[1] ;
26062
26063 if (!args) SWIG_fail;
26064 swig_obj[0] = args;
26065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26066 if (!SWIG_IsOK(res1)) {
26067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26068 }
26069 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26070 {
26071 PyThreadState* __tstate = wxPyBeginAllowThreads();
26072 {
26073 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26074 result = (wxPoint *) &_result_ref;
26075 }
26076 wxPyEndAllowThreads(__tstate);
26077 if (PyErr_Occurred()) SWIG_fail;
26078 }
26079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26080 return resultobj;
26081 fail:
26082 return NULL;
26083 }
26084
26085
26086 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26087 PyObject *resultobj = 0;
26088 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26089 wxPoint *arg2 = 0 ;
26090 void *argp1 = 0 ;
26091 int res1 = 0 ;
26092 wxPoint temp2 ;
26093 PyObject * obj0 = 0 ;
26094 PyObject * obj1 = 0 ;
26095 char * kwnames[] = {
26096 (char *) "self",(char *) "pos", NULL
26097 };
26098
26099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26101 if (!SWIG_IsOK(res1)) {
26102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26103 }
26104 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26105 {
26106 arg2 = &temp2;
26107 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26108 }
26109 {
26110 PyThreadState* __tstate = wxPyBeginAllowThreads();
26111 (arg1)->SetPosition((wxPoint const &)*arg2);
26112 wxPyEndAllowThreads(__tstate);
26113 if (PyErr_Occurred()) SWIG_fail;
26114 }
26115 resultobj = SWIG_Py_Void();
26116 return resultobj;
26117 fail:
26118 return NULL;
26119 }
26120
26121
26122 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26123 PyObject *obj;
26124 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26125 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26126 return SWIG_Py_Void();
26127 }
26128
26129 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26130 return SWIG_Python_InitShadowInstance(args);
26131 }
26132
26133 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26134 PyObject *resultobj = 0;
26135 wxIdleEvent *result = 0 ;
26136
26137 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26138 {
26139 PyThreadState* __tstate = wxPyBeginAllowThreads();
26140 result = (wxIdleEvent *)new wxIdleEvent();
26141 wxPyEndAllowThreads(__tstate);
26142 if (PyErr_Occurred()) SWIG_fail;
26143 }
26144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26145 return resultobj;
26146 fail:
26147 return NULL;
26148 }
26149
26150
26151 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26152 PyObject *resultobj = 0;
26153 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26154 bool arg2 = (bool) true ;
26155 void *argp1 = 0 ;
26156 int res1 = 0 ;
26157 bool val2 ;
26158 int ecode2 = 0 ;
26159 PyObject * obj0 = 0 ;
26160 PyObject * obj1 = 0 ;
26161 char * kwnames[] = {
26162 (char *) "self",(char *) "needMore", NULL
26163 };
26164
26165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26167 if (!SWIG_IsOK(res1)) {
26168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26169 }
26170 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26171 if (obj1) {
26172 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26173 if (!SWIG_IsOK(ecode2)) {
26174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26175 }
26176 arg2 = static_cast< bool >(val2);
26177 }
26178 {
26179 PyThreadState* __tstate = wxPyBeginAllowThreads();
26180 (arg1)->RequestMore(arg2);
26181 wxPyEndAllowThreads(__tstate);
26182 if (PyErr_Occurred()) SWIG_fail;
26183 }
26184 resultobj = SWIG_Py_Void();
26185 return resultobj;
26186 fail:
26187 return NULL;
26188 }
26189
26190
26191 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26192 PyObject *resultobj = 0;
26193 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26194 bool result;
26195 void *argp1 = 0 ;
26196 int res1 = 0 ;
26197 PyObject *swig_obj[1] ;
26198
26199 if (!args) SWIG_fail;
26200 swig_obj[0] = args;
26201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26202 if (!SWIG_IsOK(res1)) {
26203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26204 }
26205 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26206 {
26207 PyThreadState* __tstate = wxPyBeginAllowThreads();
26208 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26209 wxPyEndAllowThreads(__tstate);
26210 if (PyErr_Occurred()) SWIG_fail;
26211 }
26212 {
26213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26214 }
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26222 PyObject *resultobj = 0;
26223 wxIdleMode arg1 ;
26224 int val1 ;
26225 int ecode1 = 0 ;
26226 PyObject * obj0 = 0 ;
26227 char * kwnames[] = {
26228 (char *) "mode", NULL
26229 };
26230
26231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26232 ecode1 = SWIG_AsVal_int(obj0, &val1);
26233 if (!SWIG_IsOK(ecode1)) {
26234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26235 }
26236 arg1 = static_cast< wxIdleMode >(val1);
26237 {
26238 PyThreadState* __tstate = wxPyBeginAllowThreads();
26239 wxIdleEvent::SetMode(arg1);
26240 wxPyEndAllowThreads(__tstate);
26241 if (PyErr_Occurred()) SWIG_fail;
26242 }
26243 resultobj = SWIG_Py_Void();
26244 return resultobj;
26245 fail:
26246 return NULL;
26247 }
26248
26249
26250 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26251 PyObject *resultobj = 0;
26252 wxIdleMode result;
26253
26254 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26255 {
26256 PyThreadState* __tstate = wxPyBeginAllowThreads();
26257 result = (wxIdleMode)wxIdleEvent::GetMode();
26258 wxPyEndAllowThreads(__tstate);
26259 if (PyErr_Occurred()) SWIG_fail;
26260 }
26261 resultobj = SWIG_From_int(static_cast< int >(result));
26262 return resultobj;
26263 fail:
26264 return NULL;
26265 }
26266
26267
26268 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26269 PyObject *resultobj = 0;
26270 wxWindow *arg1 = (wxWindow *) 0 ;
26271 bool result;
26272 void *argp1 = 0 ;
26273 int res1 = 0 ;
26274 PyObject * obj0 = 0 ;
26275 char * kwnames[] = {
26276 (char *) "win", NULL
26277 };
26278
26279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26281 if (!SWIG_IsOK(res1)) {
26282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26283 }
26284 arg1 = reinterpret_cast< wxWindow * >(argp1);
26285 {
26286 PyThreadState* __tstate = wxPyBeginAllowThreads();
26287 result = (bool)wxIdleEvent::CanSend(arg1);
26288 wxPyEndAllowThreads(__tstate);
26289 if (PyErr_Occurred()) SWIG_fail;
26290 }
26291 {
26292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26293 }
26294 return resultobj;
26295 fail:
26296 return NULL;
26297 }
26298
26299
26300 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26301 PyObject *obj;
26302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26303 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26304 return SWIG_Py_Void();
26305 }
26306
26307 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26308 return SWIG_Python_InitShadowInstance(args);
26309 }
26310
26311 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26312 PyObject *resultobj = 0;
26313 int arg1 = (int) 0 ;
26314 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26315 wxPyEvent *result = 0 ;
26316 int val1 ;
26317 int ecode1 = 0 ;
26318 int val2 ;
26319 int ecode2 = 0 ;
26320 PyObject * obj0 = 0 ;
26321 PyObject * obj1 = 0 ;
26322 char * kwnames[] = {
26323 (char *) "winid",(char *) "eventType", NULL
26324 };
26325
26326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26327 if (obj0) {
26328 ecode1 = SWIG_AsVal_int(obj0, &val1);
26329 if (!SWIG_IsOK(ecode1)) {
26330 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26331 }
26332 arg1 = static_cast< int >(val1);
26333 }
26334 if (obj1) {
26335 ecode2 = SWIG_AsVal_int(obj1, &val2);
26336 if (!SWIG_IsOK(ecode2)) {
26337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26338 }
26339 arg2 = static_cast< wxEventType >(val2);
26340 }
26341 {
26342 PyThreadState* __tstate = wxPyBeginAllowThreads();
26343 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26344 wxPyEndAllowThreads(__tstate);
26345 if (PyErr_Occurred()) SWIG_fail;
26346 }
26347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26348 return resultobj;
26349 fail:
26350 return NULL;
26351 }
26352
26353
26354 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26355 PyObject *resultobj = 0;
26356 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26357 void *argp1 = 0 ;
26358 int res1 = 0 ;
26359 PyObject *swig_obj[1] ;
26360
26361 if (!args) SWIG_fail;
26362 swig_obj[0] = args;
26363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26364 if (!SWIG_IsOK(res1)) {
26365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26366 }
26367 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26368 {
26369 PyThreadState* __tstate = wxPyBeginAllowThreads();
26370 delete arg1;
26371
26372 wxPyEndAllowThreads(__tstate);
26373 if (PyErr_Occurred()) SWIG_fail;
26374 }
26375 resultobj = SWIG_Py_Void();
26376 return resultobj;
26377 fail:
26378 return NULL;
26379 }
26380
26381
26382 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26383 PyObject *resultobj = 0;
26384 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26385 PyObject *arg2 = (PyObject *) 0 ;
26386 void *argp1 = 0 ;
26387 int res1 = 0 ;
26388 PyObject * obj0 = 0 ;
26389 PyObject * obj1 = 0 ;
26390 char * kwnames[] = {
26391 (char *) "self",(char *) "self", NULL
26392 };
26393
26394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26396 if (!SWIG_IsOK(res1)) {
26397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26398 }
26399 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26400 arg2 = obj1;
26401 {
26402 PyThreadState* __tstate = wxPyBeginAllowThreads();
26403 (arg1)->SetSelf(arg2);
26404 wxPyEndAllowThreads(__tstate);
26405 if (PyErr_Occurred()) SWIG_fail;
26406 }
26407 resultobj = SWIG_Py_Void();
26408 return resultobj;
26409 fail:
26410 return NULL;
26411 }
26412
26413
26414 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26415 PyObject *resultobj = 0;
26416 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26417 PyObject *result = 0 ;
26418 void *argp1 = 0 ;
26419 int res1 = 0 ;
26420 PyObject *swig_obj[1] ;
26421
26422 if (!args) SWIG_fail;
26423 swig_obj[0] = args;
26424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26425 if (!SWIG_IsOK(res1)) {
26426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26427 }
26428 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26429 {
26430 PyThreadState* __tstate = wxPyBeginAllowThreads();
26431 result = (PyObject *)(arg1)->GetSelf();
26432 wxPyEndAllowThreads(__tstate);
26433 if (PyErr_Occurred()) SWIG_fail;
26434 }
26435 resultobj = result;
26436 return resultobj;
26437 fail:
26438 return NULL;
26439 }
26440
26441
26442 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26443 PyObject *obj;
26444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26445 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26446 return SWIG_Py_Void();
26447 }
26448
26449 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26450 return SWIG_Python_InitShadowInstance(args);
26451 }
26452
26453 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26454 PyObject *resultobj = 0;
26455 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26456 int arg2 = (int) 0 ;
26457 wxPyCommandEvent *result = 0 ;
26458 int val1 ;
26459 int ecode1 = 0 ;
26460 int val2 ;
26461 int ecode2 = 0 ;
26462 PyObject * obj0 = 0 ;
26463 PyObject * obj1 = 0 ;
26464 char * kwnames[] = {
26465 (char *) "eventType",(char *) "id", NULL
26466 };
26467
26468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26469 if (obj0) {
26470 ecode1 = SWIG_AsVal_int(obj0, &val1);
26471 if (!SWIG_IsOK(ecode1)) {
26472 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26473 }
26474 arg1 = static_cast< wxEventType >(val1);
26475 }
26476 if (obj1) {
26477 ecode2 = SWIG_AsVal_int(obj1, &val2);
26478 if (!SWIG_IsOK(ecode2)) {
26479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26480 }
26481 arg2 = static_cast< int >(val2);
26482 }
26483 {
26484 PyThreadState* __tstate = wxPyBeginAllowThreads();
26485 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26486 wxPyEndAllowThreads(__tstate);
26487 if (PyErr_Occurred()) SWIG_fail;
26488 }
26489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26490 return resultobj;
26491 fail:
26492 return NULL;
26493 }
26494
26495
26496 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26497 PyObject *resultobj = 0;
26498 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26499 void *argp1 = 0 ;
26500 int res1 = 0 ;
26501 PyObject *swig_obj[1] ;
26502
26503 if (!args) SWIG_fail;
26504 swig_obj[0] = args;
26505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26506 if (!SWIG_IsOK(res1)) {
26507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26508 }
26509 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26510 {
26511 PyThreadState* __tstate = wxPyBeginAllowThreads();
26512 delete arg1;
26513
26514 wxPyEndAllowThreads(__tstate);
26515 if (PyErr_Occurred()) SWIG_fail;
26516 }
26517 resultobj = SWIG_Py_Void();
26518 return resultobj;
26519 fail:
26520 return NULL;
26521 }
26522
26523
26524 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26525 PyObject *resultobj = 0;
26526 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26527 PyObject *arg2 = (PyObject *) 0 ;
26528 void *argp1 = 0 ;
26529 int res1 = 0 ;
26530 PyObject * obj0 = 0 ;
26531 PyObject * obj1 = 0 ;
26532 char * kwnames[] = {
26533 (char *) "self",(char *) "self", NULL
26534 };
26535
26536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26538 if (!SWIG_IsOK(res1)) {
26539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26540 }
26541 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26542 arg2 = obj1;
26543 {
26544 PyThreadState* __tstate = wxPyBeginAllowThreads();
26545 (arg1)->SetSelf(arg2);
26546 wxPyEndAllowThreads(__tstate);
26547 if (PyErr_Occurred()) SWIG_fail;
26548 }
26549 resultobj = SWIG_Py_Void();
26550 return resultobj;
26551 fail:
26552 return NULL;
26553 }
26554
26555
26556 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26557 PyObject *resultobj = 0;
26558 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26559 PyObject *result = 0 ;
26560 void *argp1 = 0 ;
26561 int res1 = 0 ;
26562 PyObject *swig_obj[1] ;
26563
26564 if (!args) SWIG_fail;
26565 swig_obj[0] = args;
26566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26567 if (!SWIG_IsOK(res1)) {
26568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26569 }
26570 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26571 {
26572 PyThreadState* __tstate = wxPyBeginAllowThreads();
26573 result = (PyObject *)(arg1)->GetSelf();
26574 wxPyEndAllowThreads(__tstate);
26575 if (PyErr_Occurred()) SWIG_fail;
26576 }
26577 resultobj = result;
26578 return resultobj;
26579 fail:
26580 return NULL;
26581 }
26582
26583
26584 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26585 PyObject *obj;
26586 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26587 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26588 return SWIG_Py_Void();
26589 }
26590
26591 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26592 return SWIG_Python_InitShadowInstance(args);
26593 }
26594
26595 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26596 PyObject *resultobj = 0;
26597 wxWindow *arg1 = (wxWindow *) 0 ;
26598 wxDateTime *arg2 = 0 ;
26599 wxEventType arg3 ;
26600 wxDateEvent *result = 0 ;
26601 void *argp1 = 0 ;
26602 int res1 = 0 ;
26603 void *argp2 = 0 ;
26604 int res2 = 0 ;
26605 int val3 ;
26606 int ecode3 = 0 ;
26607 PyObject * obj0 = 0 ;
26608 PyObject * obj1 = 0 ;
26609 PyObject * obj2 = 0 ;
26610 char * kwnames[] = {
26611 (char *) "win",(char *) "dt",(char *) "type", NULL
26612 };
26613
26614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26616 if (!SWIG_IsOK(res1)) {
26617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26618 }
26619 arg1 = reinterpret_cast< wxWindow * >(argp1);
26620 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26621 if (!SWIG_IsOK(res2)) {
26622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26623 }
26624 if (!argp2) {
26625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26626 }
26627 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26628 ecode3 = SWIG_AsVal_int(obj2, &val3);
26629 if (!SWIG_IsOK(ecode3)) {
26630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26631 }
26632 arg3 = static_cast< wxEventType >(val3);
26633 {
26634 PyThreadState* __tstate = wxPyBeginAllowThreads();
26635 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26636 wxPyEndAllowThreads(__tstate);
26637 if (PyErr_Occurred()) SWIG_fail;
26638 }
26639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26640 return resultobj;
26641 fail:
26642 return NULL;
26643 }
26644
26645
26646 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26647 PyObject *resultobj = 0;
26648 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26649 wxDateTime *result = 0 ;
26650 void *argp1 = 0 ;
26651 int res1 = 0 ;
26652 PyObject *swig_obj[1] ;
26653
26654 if (!args) SWIG_fail;
26655 swig_obj[0] = args;
26656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26657 if (!SWIG_IsOK(res1)) {
26658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26659 }
26660 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26661 {
26662 PyThreadState* __tstate = wxPyBeginAllowThreads();
26663 {
26664 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26665 result = (wxDateTime *) &_result_ref;
26666 }
26667 wxPyEndAllowThreads(__tstate);
26668 if (PyErr_Occurred()) SWIG_fail;
26669 }
26670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26671 return resultobj;
26672 fail:
26673 return NULL;
26674 }
26675
26676
26677 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26678 PyObject *resultobj = 0;
26679 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26680 wxDateTime *arg2 = 0 ;
26681 void *argp1 = 0 ;
26682 int res1 = 0 ;
26683 void *argp2 = 0 ;
26684 int res2 = 0 ;
26685 PyObject * obj0 = 0 ;
26686 PyObject * obj1 = 0 ;
26687 char * kwnames[] = {
26688 (char *) "self",(char *) "date", NULL
26689 };
26690
26691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26693 if (!SWIG_IsOK(res1)) {
26694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26695 }
26696 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26697 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26698 if (!SWIG_IsOK(res2)) {
26699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26700 }
26701 if (!argp2) {
26702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26703 }
26704 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26705 {
26706 PyThreadState* __tstate = wxPyBeginAllowThreads();
26707 (arg1)->SetDate((wxDateTime const &)*arg2);
26708 wxPyEndAllowThreads(__tstate);
26709 if (PyErr_Occurred()) SWIG_fail;
26710 }
26711 resultobj = SWIG_Py_Void();
26712 return resultobj;
26713 fail:
26714 return NULL;
26715 }
26716
26717
26718 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26719 PyObject *obj;
26720 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26721 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26722 return SWIG_Py_Void();
26723 }
26724
26725 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26726 return SWIG_Python_InitShadowInstance(args);
26727 }
26728
26729 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26730 PyObject *resultobj = 0;
26731 wxPyApp *result = 0 ;
26732
26733 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26734 {
26735 PyThreadState* __tstate = wxPyBeginAllowThreads();
26736 result = (wxPyApp *)new_wxPyApp();
26737 wxPyEndAllowThreads(__tstate);
26738 if (PyErr_Occurred()) SWIG_fail;
26739 }
26740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26741 return resultobj;
26742 fail:
26743 return NULL;
26744 }
26745
26746
26747 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26748 PyObject *resultobj = 0;
26749 wxPyApp *arg1 = (wxPyApp *) 0 ;
26750 void *argp1 = 0 ;
26751 int res1 = 0 ;
26752 PyObject *swig_obj[1] ;
26753
26754 if (!args) SWIG_fail;
26755 swig_obj[0] = args;
26756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26757 if (!SWIG_IsOK(res1)) {
26758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26759 }
26760 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26761 {
26762 PyThreadState* __tstate = wxPyBeginAllowThreads();
26763 delete arg1;
26764
26765 wxPyEndAllowThreads(__tstate);
26766 if (PyErr_Occurred()) SWIG_fail;
26767 }
26768 resultobj = SWIG_Py_Void();
26769 return resultobj;
26770 fail:
26771 return NULL;
26772 }
26773
26774
26775 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26776 PyObject *resultobj = 0;
26777 wxPyApp *arg1 = (wxPyApp *) 0 ;
26778 PyObject *arg2 = (PyObject *) 0 ;
26779 PyObject *arg3 = (PyObject *) 0 ;
26780 bool arg4 ;
26781 void *argp1 = 0 ;
26782 int res1 = 0 ;
26783 bool val4 ;
26784 int ecode4 = 0 ;
26785 PyObject * obj0 = 0 ;
26786 PyObject * obj1 = 0 ;
26787 PyObject * obj2 = 0 ;
26788 PyObject * obj3 = 0 ;
26789 char * kwnames[] = {
26790 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26791 };
26792
26793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26795 if (!SWIG_IsOK(res1)) {
26796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26797 }
26798 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26799 arg2 = obj1;
26800 arg3 = obj2;
26801 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26802 if (!SWIG_IsOK(ecode4)) {
26803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26804 }
26805 arg4 = static_cast< bool >(val4);
26806 {
26807 PyThreadState* __tstate = wxPyBeginAllowThreads();
26808 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26809 wxPyEndAllowThreads(__tstate);
26810 if (PyErr_Occurred()) SWIG_fail;
26811 }
26812 resultobj = SWIG_Py_Void();
26813 return resultobj;
26814 fail:
26815 return NULL;
26816 }
26817
26818
26819 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26820 PyObject *resultobj = 0;
26821 wxPyApp *arg1 = (wxPyApp *) 0 ;
26822 wxString result;
26823 void *argp1 = 0 ;
26824 int res1 = 0 ;
26825 PyObject *swig_obj[1] ;
26826
26827 if (!args) SWIG_fail;
26828 swig_obj[0] = args;
26829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26830 if (!SWIG_IsOK(res1)) {
26831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26832 }
26833 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26834 {
26835 PyThreadState* __tstate = wxPyBeginAllowThreads();
26836 result = ((wxPyApp const *)arg1)->GetAppName();
26837 wxPyEndAllowThreads(__tstate);
26838 if (PyErr_Occurred()) SWIG_fail;
26839 }
26840 {
26841 #if wxUSE_UNICODE
26842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26843 #else
26844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26845 #endif
26846 }
26847 return resultobj;
26848 fail:
26849 return NULL;
26850 }
26851
26852
26853 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26854 PyObject *resultobj = 0;
26855 wxPyApp *arg1 = (wxPyApp *) 0 ;
26856 wxString *arg2 = 0 ;
26857 void *argp1 = 0 ;
26858 int res1 = 0 ;
26859 bool temp2 = false ;
26860 PyObject * obj0 = 0 ;
26861 PyObject * obj1 = 0 ;
26862 char * kwnames[] = {
26863 (char *) "self",(char *) "name", NULL
26864 };
26865
26866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26868 if (!SWIG_IsOK(res1)) {
26869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26870 }
26871 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26872 {
26873 arg2 = wxString_in_helper(obj1);
26874 if (arg2 == NULL) SWIG_fail;
26875 temp2 = true;
26876 }
26877 {
26878 PyThreadState* __tstate = wxPyBeginAllowThreads();
26879 (arg1)->SetAppName((wxString const &)*arg2);
26880 wxPyEndAllowThreads(__tstate);
26881 if (PyErr_Occurred()) SWIG_fail;
26882 }
26883 resultobj = SWIG_Py_Void();
26884 {
26885 if (temp2)
26886 delete arg2;
26887 }
26888 return resultobj;
26889 fail:
26890 {
26891 if (temp2)
26892 delete arg2;
26893 }
26894 return NULL;
26895 }
26896
26897
26898 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26899 PyObject *resultobj = 0;
26900 wxPyApp *arg1 = (wxPyApp *) 0 ;
26901 wxString result;
26902 void *argp1 = 0 ;
26903 int res1 = 0 ;
26904 PyObject *swig_obj[1] ;
26905
26906 if (!args) SWIG_fail;
26907 swig_obj[0] = args;
26908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26909 if (!SWIG_IsOK(res1)) {
26910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26911 }
26912 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26913 {
26914 PyThreadState* __tstate = wxPyBeginAllowThreads();
26915 result = ((wxPyApp const *)arg1)->GetClassName();
26916 wxPyEndAllowThreads(__tstate);
26917 if (PyErr_Occurred()) SWIG_fail;
26918 }
26919 {
26920 #if wxUSE_UNICODE
26921 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26922 #else
26923 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26924 #endif
26925 }
26926 return resultobj;
26927 fail:
26928 return NULL;
26929 }
26930
26931
26932 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26933 PyObject *resultobj = 0;
26934 wxPyApp *arg1 = (wxPyApp *) 0 ;
26935 wxString *arg2 = 0 ;
26936 void *argp1 = 0 ;
26937 int res1 = 0 ;
26938 bool temp2 = false ;
26939 PyObject * obj0 = 0 ;
26940 PyObject * obj1 = 0 ;
26941 char * kwnames[] = {
26942 (char *) "self",(char *) "name", NULL
26943 };
26944
26945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
26946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26947 if (!SWIG_IsOK(res1)) {
26948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26949 }
26950 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26951 {
26952 arg2 = wxString_in_helper(obj1);
26953 if (arg2 == NULL) SWIG_fail;
26954 temp2 = true;
26955 }
26956 {
26957 PyThreadState* __tstate = wxPyBeginAllowThreads();
26958 (arg1)->SetClassName((wxString const &)*arg2);
26959 wxPyEndAllowThreads(__tstate);
26960 if (PyErr_Occurred()) SWIG_fail;
26961 }
26962 resultobj = SWIG_Py_Void();
26963 {
26964 if (temp2)
26965 delete arg2;
26966 }
26967 return resultobj;
26968 fail:
26969 {
26970 if (temp2)
26971 delete arg2;
26972 }
26973 return NULL;
26974 }
26975
26976
26977 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26978 PyObject *resultobj = 0;
26979 wxPyApp *arg1 = (wxPyApp *) 0 ;
26980 wxString *result = 0 ;
26981 void *argp1 = 0 ;
26982 int res1 = 0 ;
26983 PyObject *swig_obj[1] ;
26984
26985 if (!args) SWIG_fail;
26986 swig_obj[0] = args;
26987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26988 if (!SWIG_IsOK(res1)) {
26989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26990 }
26991 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26992 {
26993 PyThreadState* __tstate = wxPyBeginAllowThreads();
26994 {
26995 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
26996 result = (wxString *) &_result_ref;
26997 }
26998 wxPyEndAllowThreads(__tstate);
26999 if (PyErr_Occurred()) SWIG_fail;
27000 }
27001 {
27002 #if wxUSE_UNICODE
27003 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27004 #else
27005 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27006 #endif
27007 }
27008 return resultobj;
27009 fail:
27010 return NULL;
27011 }
27012
27013
27014 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27015 PyObject *resultobj = 0;
27016 wxPyApp *arg1 = (wxPyApp *) 0 ;
27017 wxString *arg2 = 0 ;
27018 void *argp1 = 0 ;
27019 int res1 = 0 ;
27020 bool temp2 = false ;
27021 PyObject * obj0 = 0 ;
27022 PyObject * obj1 = 0 ;
27023 char * kwnames[] = {
27024 (char *) "self",(char *) "name", NULL
27025 };
27026
27027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27029 if (!SWIG_IsOK(res1)) {
27030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27031 }
27032 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27033 {
27034 arg2 = wxString_in_helper(obj1);
27035 if (arg2 == NULL) SWIG_fail;
27036 temp2 = true;
27037 }
27038 {
27039 PyThreadState* __tstate = wxPyBeginAllowThreads();
27040 (arg1)->SetVendorName((wxString const &)*arg2);
27041 wxPyEndAllowThreads(__tstate);
27042 if (PyErr_Occurred()) SWIG_fail;
27043 }
27044 resultobj = SWIG_Py_Void();
27045 {
27046 if (temp2)
27047 delete arg2;
27048 }
27049 return resultobj;
27050 fail:
27051 {
27052 if (temp2)
27053 delete arg2;
27054 }
27055 return NULL;
27056 }
27057
27058
27059 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27060 PyObject *resultobj = 0;
27061 wxPyApp *arg1 = (wxPyApp *) 0 ;
27062 wxAppTraits *result = 0 ;
27063 void *argp1 = 0 ;
27064 int res1 = 0 ;
27065 PyObject *swig_obj[1] ;
27066
27067 if (!args) SWIG_fail;
27068 swig_obj[0] = args;
27069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27070 if (!SWIG_IsOK(res1)) {
27071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27072 }
27073 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27074 {
27075 PyThreadState* __tstate = wxPyBeginAllowThreads();
27076 result = (wxAppTraits *)(arg1)->GetTraits();
27077 wxPyEndAllowThreads(__tstate);
27078 if (PyErr_Occurred()) SWIG_fail;
27079 }
27080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27081 return resultobj;
27082 fail:
27083 return NULL;
27084 }
27085
27086
27087 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27088 PyObject *resultobj = 0;
27089 wxPyApp *arg1 = (wxPyApp *) 0 ;
27090 void *argp1 = 0 ;
27091 int res1 = 0 ;
27092 PyObject *swig_obj[1] ;
27093
27094 if (!args) SWIG_fail;
27095 swig_obj[0] = args;
27096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27097 if (!SWIG_IsOK(res1)) {
27098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27099 }
27100 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27101 {
27102 PyThreadState* __tstate = wxPyBeginAllowThreads();
27103 (arg1)->ProcessPendingEvents();
27104 wxPyEndAllowThreads(__tstate);
27105 if (PyErr_Occurred()) SWIG_fail;
27106 }
27107 resultobj = SWIG_Py_Void();
27108 return resultobj;
27109 fail:
27110 return NULL;
27111 }
27112
27113
27114 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27115 PyObject *resultobj = 0;
27116 wxPyApp *arg1 = (wxPyApp *) 0 ;
27117 bool arg2 = (bool) false ;
27118 bool result;
27119 void *argp1 = 0 ;
27120 int res1 = 0 ;
27121 bool val2 ;
27122 int ecode2 = 0 ;
27123 PyObject * obj0 = 0 ;
27124 PyObject * obj1 = 0 ;
27125 char * kwnames[] = {
27126 (char *) "self",(char *) "onlyIfNeeded", NULL
27127 };
27128
27129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27131 if (!SWIG_IsOK(res1)) {
27132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27133 }
27134 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27135 if (obj1) {
27136 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27137 if (!SWIG_IsOK(ecode2)) {
27138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27139 }
27140 arg2 = static_cast< bool >(val2);
27141 }
27142 {
27143 PyThreadState* __tstate = wxPyBeginAllowThreads();
27144 result = (bool)(arg1)->Yield(arg2);
27145 wxPyEndAllowThreads(__tstate);
27146 if (PyErr_Occurred()) SWIG_fail;
27147 }
27148 {
27149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27150 }
27151 return resultobj;
27152 fail:
27153 return NULL;
27154 }
27155
27156
27157 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27158 PyObject *resultobj = 0;
27159 wxPyApp *arg1 = (wxPyApp *) 0 ;
27160 void *argp1 = 0 ;
27161 int res1 = 0 ;
27162 PyObject *swig_obj[1] ;
27163
27164 if (!args) SWIG_fail;
27165 swig_obj[0] = args;
27166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27167 if (!SWIG_IsOK(res1)) {
27168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27169 }
27170 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27171 {
27172 PyThreadState* __tstate = wxPyBeginAllowThreads();
27173 (arg1)->WakeUpIdle();
27174 wxPyEndAllowThreads(__tstate);
27175 if (PyErr_Occurred()) SWIG_fail;
27176 }
27177 resultobj = SWIG_Py_Void();
27178 return resultobj;
27179 fail:
27180 return NULL;
27181 }
27182
27183
27184 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27185 PyObject *resultobj = 0;
27186 bool result;
27187
27188 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27189 {
27190 PyThreadState* __tstate = wxPyBeginAllowThreads();
27191 result = (bool)wxPyApp::IsMainLoopRunning();
27192 wxPyEndAllowThreads(__tstate);
27193 if (PyErr_Occurred()) SWIG_fail;
27194 }
27195 {
27196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27197 }
27198 return resultobj;
27199 fail:
27200 return NULL;
27201 }
27202
27203
27204 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27205 PyObject *resultobj = 0;
27206 wxPyApp *arg1 = (wxPyApp *) 0 ;
27207 int result;
27208 void *argp1 = 0 ;
27209 int res1 = 0 ;
27210 PyObject *swig_obj[1] ;
27211
27212 if (!args) SWIG_fail;
27213 swig_obj[0] = args;
27214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27215 if (!SWIG_IsOK(res1)) {
27216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27217 }
27218 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27219 {
27220 PyThreadState* __tstate = wxPyBeginAllowThreads();
27221 result = (int)(arg1)->MainLoop();
27222 wxPyEndAllowThreads(__tstate);
27223 if (PyErr_Occurred()) SWIG_fail;
27224 }
27225 resultobj = SWIG_From_int(static_cast< int >(result));
27226 return resultobj;
27227 fail:
27228 return NULL;
27229 }
27230
27231
27232 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27233 PyObject *resultobj = 0;
27234 wxPyApp *arg1 = (wxPyApp *) 0 ;
27235 void *argp1 = 0 ;
27236 int res1 = 0 ;
27237 PyObject *swig_obj[1] ;
27238
27239 if (!args) SWIG_fail;
27240 swig_obj[0] = args;
27241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27242 if (!SWIG_IsOK(res1)) {
27243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27244 }
27245 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27246 {
27247 PyThreadState* __tstate = wxPyBeginAllowThreads();
27248 (arg1)->Exit();
27249 wxPyEndAllowThreads(__tstate);
27250 if (PyErr_Occurred()) SWIG_fail;
27251 }
27252 resultobj = SWIG_Py_Void();
27253 return resultobj;
27254 fail:
27255 return NULL;
27256 }
27257
27258
27259 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27260 PyObject *resultobj = 0;
27261 wxPyApp *arg1 = (wxPyApp *) 0 ;
27262 void *argp1 = 0 ;
27263 int res1 = 0 ;
27264 PyObject *swig_obj[1] ;
27265
27266 if (!args) SWIG_fail;
27267 swig_obj[0] = args;
27268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27269 if (!SWIG_IsOK(res1)) {
27270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27271 }
27272 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27273 {
27274 PyThreadState* __tstate = wxPyBeginAllowThreads();
27275 (arg1)->ExitMainLoop();
27276 wxPyEndAllowThreads(__tstate);
27277 if (PyErr_Occurred()) SWIG_fail;
27278 }
27279 resultobj = SWIG_Py_Void();
27280 return resultobj;
27281 fail:
27282 return NULL;
27283 }
27284
27285
27286 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27287 PyObject *resultobj = 0;
27288 wxPyApp *arg1 = (wxPyApp *) 0 ;
27289 bool result;
27290 void *argp1 = 0 ;
27291 int res1 = 0 ;
27292 PyObject *swig_obj[1] ;
27293
27294 if (!args) SWIG_fail;
27295 swig_obj[0] = args;
27296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27297 if (!SWIG_IsOK(res1)) {
27298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27299 }
27300 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27301 {
27302 PyThreadState* __tstate = wxPyBeginAllowThreads();
27303 result = (bool)(arg1)->Pending();
27304 wxPyEndAllowThreads(__tstate);
27305 if (PyErr_Occurred()) SWIG_fail;
27306 }
27307 {
27308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27309 }
27310 return resultobj;
27311 fail:
27312 return NULL;
27313 }
27314
27315
27316 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27317 PyObject *resultobj = 0;
27318 wxPyApp *arg1 = (wxPyApp *) 0 ;
27319 bool result;
27320 void *argp1 = 0 ;
27321 int res1 = 0 ;
27322 PyObject *swig_obj[1] ;
27323
27324 if (!args) SWIG_fail;
27325 swig_obj[0] = args;
27326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27327 if (!SWIG_IsOK(res1)) {
27328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27329 }
27330 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27331 {
27332 PyThreadState* __tstate = wxPyBeginAllowThreads();
27333 result = (bool)(arg1)->Dispatch();
27334 wxPyEndAllowThreads(__tstate);
27335 if (PyErr_Occurred()) SWIG_fail;
27336 }
27337 {
27338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27339 }
27340 return resultobj;
27341 fail:
27342 return NULL;
27343 }
27344
27345
27346 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27347 PyObject *resultobj = 0;
27348 wxPyApp *arg1 = (wxPyApp *) 0 ;
27349 bool result;
27350 void *argp1 = 0 ;
27351 int res1 = 0 ;
27352 PyObject *swig_obj[1] ;
27353
27354 if (!args) SWIG_fail;
27355 swig_obj[0] = args;
27356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27357 if (!SWIG_IsOK(res1)) {
27358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27359 }
27360 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27361 {
27362 PyThreadState* __tstate = wxPyBeginAllowThreads();
27363 result = (bool)(arg1)->ProcessIdle();
27364 wxPyEndAllowThreads(__tstate);
27365 if (PyErr_Occurred()) SWIG_fail;
27366 }
27367 {
27368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27369 }
27370 return resultobj;
27371 fail:
27372 return NULL;
27373 }
27374
27375
27376 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27377 PyObject *resultobj = 0;
27378 wxPyApp *arg1 = (wxPyApp *) 0 ;
27379 wxWindow *arg2 = (wxWindow *) 0 ;
27380 wxIdleEvent *arg3 = 0 ;
27381 bool result;
27382 void *argp1 = 0 ;
27383 int res1 = 0 ;
27384 void *argp2 = 0 ;
27385 int res2 = 0 ;
27386 void *argp3 = 0 ;
27387 int res3 = 0 ;
27388 PyObject * obj0 = 0 ;
27389 PyObject * obj1 = 0 ;
27390 PyObject * obj2 = 0 ;
27391 char * kwnames[] = {
27392 (char *) "self",(char *) "win",(char *) "event", NULL
27393 };
27394
27395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27397 if (!SWIG_IsOK(res1)) {
27398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27399 }
27400 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27401 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27402 if (!SWIG_IsOK(res2)) {
27403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27404 }
27405 arg2 = reinterpret_cast< wxWindow * >(argp2);
27406 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27407 if (!SWIG_IsOK(res3)) {
27408 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27409 }
27410 if (!argp3) {
27411 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27412 }
27413 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27414 {
27415 PyThreadState* __tstate = wxPyBeginAllowThreads();
27416 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27417 wxPyEndAllowThreads(__tstate);
27418 if (PyErr_Occurred()) SWIG_fail;
27419 }
27420 {
27421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27422 }
27423 return resultobj;
27424 fail:
27425 return NULL;
27426 }
27427
27428
27429 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27430 PyObject *resultobj = 0;
27431 wxPyApp *arg1 = (wxPyApp *) 0 ;
27432 bool result;
27433 void *argp1 = 0 ;
27434 int res1 = 0 ;
27435 PyObject *swig_obj[1] ;
27436
27437 if (!args) SWIG_fail;
27438 swig_obj[0] = args;
27439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27440 if (!SWIG_IsOK(res1)) {
27441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27442 }
27443 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27444 {
27445 PyThreadState* __tstate = wxPyBeginAllowThreads();
27446 result = (bool)((wxPyApp const *)arg1)->IsActive();
27447 wxPyEndAllowThreads(__tstate);
27448 if (PyErr_Occurred()) SWIG_fail;
27449 }
27450 {
27451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27452 }
27453 return resultobj;
27454 fail:
27455 return NULL;
27456 }
27457
27458
27459 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27460 PyObject *resultobj = 0;
27461 wxPyApp *arg1 = (wxPyApp *) 0 ;
27462 wxWindow *arg2 = (wxWindow *) 0 ;
27463 void *argp1 = 0 ;
27464 int res1 = 0 ;
27465 void *argp2 = 0 ;
27466 int res2 = 0 ;
27467 PyObject * obj0 = 0 ;
27468 PyObject * obj1 = 0 ;
27469 char * kwnames[] = {
27470 (char *) "self",(char *) "win", NULL
27471 };
27472
27473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27475 if (!SWIG_IsOK(res1)) {
27476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27477 }
27478 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27479 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27480 if (!SWIG_IsOK(res2)) {
27481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27482 }
27483 arg2 = reinterpret_cast< wxWindow * >(argp2);
27484 {
27485 PyThreadState* __tstate = wxPyBeginAllowThreads();
27486 (arg1)->SetTopWindow(arg2);
27487 wxPyEndAllowThreads(__tstate);
27488 if (PyErr_Occurred()) SWIG_fail;
27489 }
27490 resultobj = SWIG_Py_Void();
27491 return resultobj;
27492 fail:
27493 return NULL;
27494 }
27495
27496
27497 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27498 PyObject *resultobj = 0;
27499 wxPyApp *arg1 = (wxPyApp *) 0 ;
27500 wxWindow *result = 0 ;
27501 void *argp1 = 0 ;
27502 int res1 = 0 ;
27503 PyObject *swig_obj[1] ;
27504
27505 if (!args) SWIG_fail;
27506 swig_obj[0] = args;
27507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27508 if (!SWIG_IsOK(res1)) {
27509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27510 }
27511 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27512 {
27513 PyThreadState* __tstate = wxPyBeginAllowThreads();
27514 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27515 wxPyEndAllowThreads(__tstate);
27516 if (PyErr_Occurred()) SWIG_fail;
27517 }
27518 {
27519 resultobj = wxPyMake_wxObject(result, (bool)0);
27520 }
27521 return resultobj;
27522 fail:
27523 return NULL;
27524 }
27525
27526
27527 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj = 0;
27529 wxPyApp *arg1 = (wxPyApp *) 0 ;
27530 bool arg2 ;
27531 void *argp1 = 0 ;
27532 int res1 = 0 ;
27533 bool val2 ;
27534 int ecode2 = 0 ;
27535 PyObject * obj0 = 0 ;
27536 PyObject * obj1 = 0 ;
27537 char * kwnames[] = {
27538 (char *) "self",(char *) "flag", NULL
27539 };
27540
27541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27543 if (!SWIG_IsOK(res1)) {
27544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27545 }
27546 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27547 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27548 if (!SWIG_IsOK(ecode2)) {
27549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27550 }
27551 arg2 = static_cast< bool >(val2);
27552 {
27553 PyThreadState* __tstate = wxPyBeginAllowThreads();
27554 (arg1)->SetExitOnFrameDelete(arg2);
27555 wxPyEndAllowThreads(__tstate);
27556 if (PyErr_Occurred()) SWIG_fail;
27557 }
27558 resultobj = SWIG_Py_Void();
27559 return resultobj;
27560 fail:
27561 return NULL;
27562 }
27563
27564
27565 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27566 PyObject *resultobj = 0;
27567 wxPyApp *arg1 = (wxPyApp *) 0 ;
27568 bool result;
27569 void *argp1 = 0 ;
27570 int res1 = 0 ;
27571 PyObject *swig_obj[1] ;
27572
27573 if (!args) SWIG_fail;
27574 swig_obj[0] = args;
27575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27576 if (!SWIG_IsOK(res1)) {
27577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27578 }
27579 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27580 {
27581 PyThreadState* __tstate = wxPyBeginAllowThreads();
27582 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 {
27587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27588 }
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27596 PyObject *resultobj = 0;
27597 wxPyApp *arg1 = (wxPyApp *) 0 ;
27598 bool arg2 ;
27599 void *argp1 = 0 ;
27600 int res1 = 0 ;
27601 bool val2 ;
27602 int ecode2 = 0 ;
27603 PyObject * obj0 = 0 ;
27604 PyObject * obj1 = 0 ;
27605 char * kwnames[] = {
27606 (char *) "self",(char *) "flag", NULL
27607 };
27608
27609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27611 if (!SWIG_IsOK(res1)) {
27612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27613 }
27614 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27615 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27616 if (!SWIG_IsOK(ecode2)) {
27617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27618 }
27619 arg2 = static_cast< bool >(val2);
27620 {
27621 PyThreadState* __tstate = wxPyBeginAllowThreads();
27622 (arg1)->SetUseBestVisual(arg2);
27623 wxPyEndAllowThreads(__tstate);
27624 if (PyErr_Occurred()) SWIG_fail;
27625 }
27626 resultobj = SWIG_Py_Void();
27627 return resultobj;
27628 fail:
27629 return NULL;
27630 }
27631
27632
27633 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27634 PyObject *resultobj = 0;
27635 wxPyApp *arg1 = (wxPyApp *) 0 ;
27636 bool result;
27637 void *argp1 = 0 ;
27638 int res1 = 0 ;
27639 PyObject *swig_obj[1] ;
27640
27641 if (!args) SWIG_fail;
27642 swig_obj[0] = args;
27643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27644 if (!SWIG_IsOK(res1)) {
27645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27646 }
27647 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27648 {
27649 PyThreadState* __tstate = wxPyBeginAllowThreads();
27650 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27651 wxPyEndAllowThreads(__tstate);
27652 if (PyErr_Occurred()) SWIG_fail;
27653 }
27654 {
27655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27656 }
27657 return resultobj;
27658 fail:
27659 return NULL;
27660 }
27661
27662
27663 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27664 PyObject *resultobj = 0;
27665 wxPyApp *arg1 = (wxPyApp *) 0 ;
27666 int arg2 ;
27667 void *argp1 = 0 ;
27668 int res1 = 0 ;
27669 int val2 ;
27670 int ecode2 = 0 ;
27671 PyObject * obj0 = 0 ;
27672 PyObject * obj1 = 0 ;
27673 char * kwnames[] = {
27674 (char *) "self",(char *) "mode", NULL
27675 };
27676
27677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27679 if (!SWIG_IsOK(res1)) {
27680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27681 }
27682 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27683 ecode2 = SWIG_AsVal_int(obj1, &val2);
27684 if (!SWIG_IsOK(ecode2)) {
27685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27686 }
27687 arg2 = static_cast< int >(val2);
27688 {
27689 PyThreadState* __tstate = wxPyBeginAllowThreads();
27690 (arg1)->SetPrintMode(arg2);
27691 wxPyEndAllowThreads(__tstate);
27692 if (PyErr_Occurred()) SWIG_fail;
27693 }
27694 resultobj = SWIG_Py_Void();
27695 return resultobj;
27696 fail:
27697 return NULL;
27698 }
27699
27700
27701 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27702 PyObject *resultobj = 0;
27703 wxPyApp *arg1 = (wxPyApp *) 0 ;
27704 int result;
27705 void *argp1 = 0 ;
27706 int res1 = 0 ;
27707 PyObject *swig_obj[1] ;
27708
27709 if (!args) SWIG_fail;
27710 swig_obj[0] = args;
27711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27712 if (!SWIG_IsOK(res1)) {
27713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27714 }
27715 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27716 {
27717 PyThreadState* __tstate = wxPyBeginAllowThreads();
27718 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 resultobj = SWIG_From_int(static_cast< int >(result));
27723 return resultobj;
27724 fail:
27725 return NULL;
27726 }
27727
27728
27729 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27730 PyObject *resultobj = 0;
27731 wxPyApp *arg1 = (wxPyApp *) 0 ;
27732 int arg2 ;
27733 void *argp1 = 0 ;
27734 int res1 = 0 ;
27735 int val2 ;
27736 int ecode2 = 0 ;
27737 PyObject * obj0 = 0 ;
27738 PyObject * obj1 = 0 ;
27739 char * kwnames[] = {
27740 (char *) "self",(char *) "mode", NULL
27741 };
27742
27743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27745 if (!SWIG_IsOK(res1)) {
27746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27747 }
27748 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27749 ecode2 = SWIG_AsVal_int(obj1, &val2);
27750 if (!SWIG_IsOK(ecode2)) {
27751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27752 }
27753 arg2 = static_cast< int >(val2);
27754 {
27755 PyThreadState* __tstate = wxPyBeginAllowThreads();
27756 (arg1)->SetAssertMode(arg2);
27757 wxPyEndAllowThreads(__tstate);
27758 if (PyErr_Occurred()) SWIG_fail;
27759 }
27760 resultobj = SWIG_Py_Void();
27761 return resultobj;
27762 fail:
27763 return NULL;
27764 }
27765
27766
27767 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27768 PyObject *resultobj = 0;
27769 wxPyApp *arg1 = (wxPyApp *) 0 ;
27770 int result;
27771 void *argp1 = 0 ;
27772 int res1 = 0 ;
27773 PyObject *swig_obj[1] ;
27774
27775 if (!args) SWIG_fail;
27776 swig_obj[0] = args;
27777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27778 if (!SWIG_IsOK(res1)) {
27779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27780 }
27781 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27782 {
27783 PyThreadState* __tstate = wxPyBeginAllowThreads();
27784 result = (int)(arg1)->GetAssertMode();
27785 wxPyEndAllowThreads(__tstate);
27786 if (PyErr_Occurred()) SWIG_fail;
27787 }
27788 resultobj = SWIG_From_int(static_cast< int >(result));
27789 return resultobj;
27790 fail:
27791 return NULL;
27792 }
27793
27794
27795 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27796 PyObject *resultobj = 0;
27797 bool result;
27798
27799 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27800 {
27801 PyThreadState* __tstate = wxPyBeginAllowThreads();
27802 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27803 wxPyEndAllowThreads(__tstate);
27804 if (PyErr_Occurred()) SWIG_fail;
27805 }
27806 {
27807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27808 }
27809 return resultobj;
27810 fail:
27811 return NULL;
27812 }
27813
27814
27815 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27816 PyObject *resultobj = 0;
27817 long result;
27818
27819 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27820 {
27821 PyThreadState* __tstate = wxPyBeginAllowThreads();
27822 result = (long)wxPyApp::GetMacAboutMenuItemId();
27823 wxPyEndAllowThreads(__tstate);
27824 if (PyErr_Occurred()) SWIG_fail;
27825 }
27826 resultobj = SWIG_From_long(static_cast< long >(result));
27827 return resultobj;
27828 fail:
27829 return NULL;
27830 }
27831
27832
27833 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27834 PyObject *resultobj = 0;
27835 long result;
27836
27837 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27838 {
27839 PyThreadState* __tstate = wxPyBeginAllowThreads();
27840 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27841 wxPyEndAllowThreads(__tstate);
27842 if (PyErr_Occurred()) SWIG_fail;
27843 }
27844 resultobj = SWIG_From_long(static_cast< long >(result));
27845 return resultobj;
27846 fail:
27847 return NULL;
27848 }
27849
27850
27851 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27852 PyObject *resultobj = 0;
27853 long result;
27854
27855 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27856 {
27857 PyThreadState* __tstate = wxPyBeginAllowThreads();
27858 result = (long)wxPyApp::GetMacExitMenuItemId();
27859 wxPyEndAllowThreads(__tstate);
27860 if (PyErr_Occurred()) SWIG_fail;
27861 }
27862 resultobj = SWIG_From_long(static_cast< long >(result));
27863 return resultobj;
27864 fail:
27865 return NULL;
27866 }
27867
27868
27869 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27870 PyObject *resultobj = 0;
27871 wxString result;
27872
27873 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27874 {
27875 PyThreadState* __tstate = wxPyBeginAllowThreads();
27876 result = wxPyApp::GetMacHelpMenuTitleName();
27877 wxPyEndAllowThreads(__tstate);
27878 if (PyErr_Occurred()) SWIG_fail;
27879 }
27880 {
27881 #if wxUSE_UNICODE
27882 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27883 #else
27884 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27885 #endif
27886 }
27887 return resultobj;
27888 fail:
27889 return NULL;
27890 }
27891
27892
27893 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27894 PyObject *resultobj = 0;
27895 bool arg1 ;
27896 bool val1 ;
27897 int ecode1 = 0 ;
27898 PyObject * obj0 = 0 ;
27899 char * kwnames[] = {
27900 (char *) "val", NULL
27901 };
27902
27903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27904 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27905 if (!SWIG_IsOK(ecode1)) {
27906 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27907 }
27908 arg1 = static_cast< bool >(val1);
27909 {
27910 PyThreadState* __tstate = wxPyBeginAllowThreads();
27911 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27912 wxPyEndAllowThreads(__tstate);
27913 if (PyErr_Occurred()) SWIG_fail;
27914 }
27915 resultobj = SWIG_Py_Void();
27916 return resultobj;
27917 fail:
27918 return NULL;
27919 }
27920
27921
27922 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27923 PyObject *resultobj = 0;
27924 long arg1 ;
27925 long val1 ;
27926 int ecode1 = 0 ;
27927 PyObject * obj0 = 0 ;
27928 char * kwnames[] = {
27929 (char *) "val", NULL
27930 };
27931
27932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
27933 ecode1 = SWIG_AsVal_long(obj0, &val1);
27934 if (!SWIG_IsOK(ecode1)) {
27935 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
27936 }
27937 arg1 = static_cast< long >(val1);
27938 {
27939 PyThreadState* __tstate = wxPyBeginAllowThreads();
27940 wxPyApp::SetMacAboutMenuItemId(arg1);
27941 wxPyEndAllowThreads(__tstate);
27942 if (PyErr_Occurred()) SWIG_fail;
27943 }
27944 resultobj = SWIG_Py_Void();
27945 return resultobj;
27946 fail:
27947 return NULL;
27948 }
27949
27950
27951 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27952 PyObject *resultobj = 0;
27953 long arg1 ;
27954 long val1 ;
27955 int ecode1 = 0 ;
27956 PyObject * obj0 = 0 ;
27957 char * kwnames[] = {
27958 (char *) "val", NULL
27959 };
27960
27961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
27962 ecode1 = SWIG_AsVal_long(obj0, &val1);
27963 if (!SWIG_IsOK(ecode1)) {
27964 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
27965 }
27966 arg1 = static_cast< long >(val1);
27967 {
27968 PyThreadState* __tstate = wxPyBeginAllowThreads();
27969 wxPyApp::SetMacPreferencesMenuItemId(arg1);
27970 wxPyEndAllowThreads(__tstate);
27971 if (PyErr_Occurred()) SWIG_fail;
27972 }
27973 resultobj = SWIG_Py_Void();
27974 return resultobj;
27975 fail:
27976 return NULL;
27977 }
27978
27979
27980 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27981 PyObject *resultobj = 0;
27982 long arg1 ;
27983 long val1 ;
27984 int ecode1 = 0 ;
27985 PyObject * obj0 = 0 ;
27986 char * kwnames[] = {
27987 (char *) "val", NULL
27988 };
27989
27990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
27991 ecode1 = SWIG_AsVal_long(obj0, &val1);
27992 if (!SWIG_IsOK(ecode1)) {
27993 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
27994 }
27995 arg1 = static_cast< long >(val1);
27996 {
27997 PyThreadState* __tstate = wxPyBeginAllowThreads();
27998 wxPyApp::SetMacExitMenuItemId(arg1);
27999 wxPyEndAllowThreads(__tstate);
28000 if (PyErr_Occurred()) SWIG_fail;
28001 }
28002 resultobj = SWIG_Py_Void();
28003 return resultobj;
28004 fail:
28005 return NULL;
28006 }
28007
28008
28009 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28010 PyObject *resultobj = 0;
28011 wxString *arg1 = 0 ;
28012 bool temp1 = false ;
28013 PyObject * obj0 = 0 ;
28014 char * kwnames[] = {
28015 (char *) "val", NULL
28016 };
28017
28018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28019 {
28020 arg1 = wxString_in_helper(obj0);
28021 if (arg1 == NULL) SWIG_fail;
28022 temp1 = true;
28023 }
28024 {
28025 PyThreadState* __tstate = wxPyBeginAllowThreads();
28026 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28027 wxPyEndAllowThreads(__tstate);
28028 if (PyErr_Occurred()) SWIG_fail;
28029 }
28030 resultobj = SWIG_Py_Void();
28031 {
28032 if (temp1)
28033 delete arg1;
28034 }
28035 return resultobj;
28036 fail:
28037 {
28038 if (temp1)
28039 delete arg1;
28040 }
28041 return NULL;
28042 }
28043
28044
28045 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28046 PyObject *resultobj = 0;
28047 wxPyApp *arg1 = (wxPyApp *) 0 ;
28048 void *argp1 = 0 ;
28049 int res1 = 0 ;
28050 PyObject *swig_obj[1] ;
28051
28052 if (!args) SWIG_fail;
28053 swig_obj[0] = args;
28054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28055 if (!SWIG_IsOK(res1)) {
28056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28057 }
28058 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28059 {
28060 PyThreadState* __tstate = wxPyBeginAllowThreads();
28061 (arg1)->_BootstrapApp();
28062 wxPyEndAllowThreads(__tstate);
28063 if (PyErr_Occurred()) SWIG_fail;
28064 }
28065 resultobj = SWIG_Py_Void();
28066 return resultobj;
28067 fail:
28068 return NULL;
28069 }
28070
28071
28072 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28073 PyObject *resultobj = 0;
28074 int result;
28075
28076 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28077 {
28078 PyThreadState* __tstate = wxPyBeginAllowThreads();
28079 result = (int)wxPyApp_GetComCtl32Version();
28080 wxPyEndAllowThreads(__tstate);
28081 if (PyErr_Occurred()) SWIG_fail;
28082 }
28083 resultobj = SWIG_From_int(static_cast< int >(result));
28084 return resultobj;
28085 fail:
28086 return NULL;
28087 }
28088
28089
28090 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28091 PyObject *obj;
28092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28093 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28094 return SWIG_Py_Void();
28095 }
28096
28097 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28098 return SWIG_Python_InitShadowInstance(args);
28099 }
28100
28101 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28102 PyObject *resultobj = 0;
28103
28104 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28105 {
28106 PyThreadState* __tstate = wxPyBeginAllowThreads();
28107 wxExit();
28108 wxPyEndAllowThreads(__tstate);
28109 if (PyErr_Occurred()) SWIG_fail;
28110 }
28111 resultobj = SWIG_Py_Void();
28112 return resultobj;
28113 fail:
28114 return NULL;
28115 }
28116
28117
28118 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28119 PyObject *resultobj = 0;
28120 bool result;
28121
28122 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28123 {
28124 PyThreadState* __tstate = wxPyBeginAllowThreads();
28125 result = (bool)wxYield();
28126 wxPyEndAllowThreads(__tstate);
28127 if (PyErr_Occurred()) SWIG_fail;
28128 }
28129 {
28130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28131 }
28132 return resultobj;
28133 fail:
28134 return NULL;
28135 }
28136
28137
28138 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28139 PyObject *resultobj = 0;
28140 bool result;
28141
28142 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28143 {
28144 PyThreadState* __tstate = wxPyBeginAllowThreads();
28145 result = (bool)wxYieldIfNeeded();
28146 wxPyEndAllowThreads(__tstate);
28147 if (PyErr_Occurred()) SWIG_fail;
28148 }
28149 {
28150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28151 }
28152 return resultobj;
28153 fail:
28154 return NULL;
28155 }
28156
28157
28158 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28159 PyObject *resultobj = 0;
28160 wxWindow *arg1 = (wxWindow *) NULL ;
28161 bool arg2 = (bool) false ;
28162 bool result;
28163 void *argp1 = 0 ;
28164 int res1 = 0 ;
28165 bool val2 ;
28166 int ecode2 = 0 ;
28167 PyObject * obj0 = 0 ;
28168 PyObject * obj1 = 0 ;
28169 char * kwnames[] = {
28170 (char *) "win",(char *) "onlyIfNeeded", NULL
28171 };
28172
28173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28174 if (obj0) {
28175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28176 if (!SWIG_IsOK(res1)) {
28177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28178 }
28179 arg1 = reinterpret_cast< wxWindow * >(argp1);
28180 }
28181 if (obj1) {
28182 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28183 if (!SWIG_IsOK(ecode2)) {
28184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28185 }
28186 arg2 = static_cast< bool >(val2);
28187 }
28188 {
28189 PyThreadState* __tstate = wxPyBeginAllowThreads();
28190 result = (bool)wxSafeYield(arg1,arg2);
28191 wxPyEndAllowThreads(__tstate);
28192 if (PyErr_Occurred()) SWIG_fail;
28193 }
28194 {
28195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28196 }
28197 return resultobj;
28198 fail:
28199 return NULL;
28200 }
28201
28202
28203 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28204 PyObject *resultobj = 0;
28205
28206 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28207 {
28208 PyThreadState* __tstate = wxPyBeginAllowThreads();
28209 wxWakeUpIdle();
28210 wxPyEndAllowThreads(__tstate);
28211 if (PyErr_Occurred()) SWIG_fail;
28212 }
28213 resultobj = SWIG_Py_Void();
28214 return resultobj;
28215 fail:
28216 return NULL;
28217 }
28218
28219
28220 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28221 PyObject *resultobj = 0;
28222 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28223 wxEvent *arg2 = 0 ;
28224 void *argp1 = 0 ;
28225 int res1 = 0 ;
28226 void *argp2 = 0 ;
28227 int res2 = 0 ;
28228 PyObject * obj0 = 0 ;
28229 PyObject * obj1 = 0 ;
28230 char * kwnames[] = {
28231 (char *) "dest",(char *) "event", NULL
28232 };
28233
28234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28236 if (!SWIG_IsOK(res1)) {
28237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28238 }
28239 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28240 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28241 if (!SWIG_IsOK(res2)) {
28242 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28243 }
28244 if (!argp2) {
28245 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28246 }
28247 arg2 = reinterpret_cast< wxEvent * >(argp2);
28248 {
28249 PyThreadState* __tstate = wxPyBeginAllowThreads();
28250 wxPostEvent(arg1,*arg2);
28251 wxPyEndAllowThreads(__tstate);
28252 if (PyErr_Occurred()) SWIG_fail;
28253 }
28254 resultobj = SWIG_Py_Void();
28255 return resultobj;
28256 fail:
28257 return NULL;
28258 }
28259
28260
28261 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28262 PyObject *resultobj = 0;
28263
28264 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28265 {
28266 PyThreadState* __tstate = wxPyBeginAllowThreads();
28267 wxApp_CleanUp();
28268 wxPyEndAllowThreads(__tstate);
28269 if (PyErr_Occurred()) SWIG_fail;
28270 }
28271 resultobj = SWIG_Py_Void();
28272 return resultobj;
28273 fail:
28274 return NULL;
28275 }
28276
28277
28278 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28279 PyObject *resultobj = 0;
28280 wxPyApp *result = 0 ;
28281
28282 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28283 {
28284 PyThreadState* __tstate = wxPyBeginAllowThreads();
28285 result = (wxPyApp *)wxPyGetApp();
28286 wxPyEndAllowThreads(__tstate);
28287 if (PyErr_Occurred()) SWIG_fail;
28288 }
28289 {
28290 resultobj = wxPyMake_wxObject(result, 0);
28291 }
28292 return resultobj;
28293 fail:
28294 return NULL;
28295 }
28296
28297
28298 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28299 PyObject *resultobj = 0;
28300 char *arg1 = (char *) 0 ;
28301 int res1 ;
28302 char *buf1 = 0 ;
28303 int alloc1 = 0 ;
28304 PyObject * obj0 = 0 ;
28305 char * kwnames[] = {
28306 (char *) "encoding", NULL
28307 };
28308
28309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28310 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28311 if (!SWIG_IsOK(res1)) {
28312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28313 }
28314 arg1 = buf1;
28315 {
28316 PyThreadState* __tstate = wxPyBeginAllowThreads();
28317 wxSetDefaultPyEncoding((char const *)arg1);
28318 wxPyEndAllowThreads(__tstate);
28319 if (PyErr_Occurred()) SWIG_fail;
28320 }
28321 resultobj = SWIG_Py_Void();
28322 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28323 return resultobj;
28324 fail:
28325 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28326 return NULL;
28327 }
28328
28329
28330 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28331 PyObject *resultobj = 0;
28332 char *result = 0 ;
28333
28334 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28335 {
28336 PyThreadState* __tstate = wxPyBeginAllowThreads();
28337 result = (char *)wxGetDefaultPyEncoding();
28338 wxPyEndAllowThreads(__tstate);
28339 if (PyErr_Occurred()) SWIG_fail;
28340 }
28341 resultobj = SWIG_FromCharPtr(result);
28342 return resultobj;
28343 fail:
28344 return NULL;
28345 }
28346
28347
28348 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28349 PyObject *resultobj = 0;
28350 wxEventLoop *result = 0 ;
28351
28352 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28353 {
28354 PyThreadState* __tstate = wxPyBeginAllowThreads();
28355 result = (wxEventLoop *)new wxEventLoop();
28356 wxPyEndAllowThreads(__tstate);
28357 if (PyErr_Occurred()) SWIG_fail;
28358 }
28359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28360 return resultobj;
28361 fail:
28362 return NULL;
28363 }
28364
28365
28366 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28367 PyObject *resultobj = 0;
28368 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28369 void *argp1 = 0 ;
28370 int res1 = 0 ;
28371 PyObject *swig_obj[1] ;
28372
28373 if (!args) SWIG_fail;
28374 swig_obj[0] = args;
28375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28376 if (!SWIG_IsOK(res1)) {
28377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28378 }
28379 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28380 {
28381 PyThreadState* __tstate = wxPyBeginAllowThreads();
28382 delete arg1;
28383
28384 wxPyEndAllowThreads(__tstate);
28385 if (PyErr_Occurred()) SWIG_fail;
28386 }
28387 resultobj = SWIG_Py_Void();
28388 return resultobj;
28389 fail:
28390 return NULL;
28391 }
28392
28393
28394 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28395 PyObject *resultobj = 0;
28396 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28397 int result;
28398 void *argp1 = 0 ;
28399 int res1 = 0 ;
28400 PyObject *swig_obj[1] ;
28401
28402 if (!args) SWIG_fail;
28403 swig_obj[0] = args;
28404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28405 if (!SWIG_IsOK(res1)) {
28406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28407 }
28408 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28409 {
28410 PyThreadState* __tstate = wxPyBeginAllowThreads();
28411 result = (int)(arg1)->Run();
28412 wxPyEndAllowThreads(__tstate);
28413 if (PyErr_Occurred()) SWIG_fail;
28414 }
28415 resultobj = SWIG_From_int(static_cast< int >(result));
28416 return resultobj;
28417 fail:
28418 return NULL;
28419 }
28420
28421
28422 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28423 PyObject *resultobj = 0;
28424 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28425 int arg2 = (int) 0 ;
28426 void *argp1 = 0 ;
28427 int res1 = 0 ;
28428 int val2 ;
28429 int ecode2 = 0 ;
28430 PyObject * obj0 = 0 ;
28431 PyObject * obj1 = 0 ;
28432 char * kwnames[] = {
28433 (char *) "self",(char *) "rc", NULL
28434 };
28435
28436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28438 if (!SWIG_IsOK(res1)) {
28439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28440 }
28441 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28442 if (obj1) {
28443 ecode2 = SWIG_AsVal_int(obj1, &val2);
28444 if (!SWIG_IsOK(ecode2)) {
28445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28446 }
28447 arg2 = static_cast< int >(val2);
28448 }
28449 {
28450 PyThreadState* __tstate = wxPyBeginAllowThreads();
28451 (arg1)->Exit(arg2);
28452 wxPyEndAllowThreads(__tstate);
28453 if (PyErr_Occurred()) SWIG_fail;
28454 }
28455 resultobj = SWIG_Py_Void();
28456 return resultobj;
28457 fail:
28458 return NULL;
28459 }
28460
28461
28462 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28463 PyObject *resultobj = 0;
28464 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28465 bool result;
28466 void *argp1 = 0 ;
28467 int res1 = 0 ;
28468 PyObject *swig_obj[1] ;
28469
28470 if (!args) SWIG_fail;
28471 swig_obj[0] = args;
28472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28473 if (!SWIG_IsOK(res1)) {
28474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28475 }
28476 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28477 {
28478 PyThreadState* __tstate = wxPyBeginAllowThreads();
28479 result = (bool)((wxEventLoop const *)arg1)->Pending();
28480 wxPyEndAllowThreads(__tstate);
28481 if (PyErr_Occurred()) SWIG_fail;
28482 }
28483 {
28484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28485 }
28486 return resultobj;
28487 fail:
28488 return NULL;
28489 }
28490
28491
28492 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28493 PyObject *resultobj = 0;
28494 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28495 bool result;
28496 void *argp1 = 0 ;
28497 int res1 = 0 ;
28498 PyObject *swig_obj[1] ;
28499
28500 if (!args) SWIG_fail;
28501 swig_obj[0] = args;
28502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28503 if (!SWIG_IsOK(res1)) {
28504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28505 }
28506 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28507 {
28508 PyThreadState* __tstate = wxPyBeginAllowThreads();
28509 result = (bool)(arg1)->Dispatch();
28510 wxPyEndAllowThreads(__tstate);
28511 if (PyErr_Occurred()) SWIG_fail;
28512 }
28513 {
28514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28515 }
28516 return resultobj;
28517 fail:
28518 return NULL;
28519 }
28520
28521
28522 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28523 PyObject *resultobj = 0;
28524 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28525 bool result;
28526 void *argp1 = 0 ;
28527 int res1 = 0 ;
28528 PyObject *swig_obj[1] ;
28529
28530 if (!args) SWIG_fail;
28531 swig_obj[0] = args;
28532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28533 if (!SWIG_IsOK(res1)) {
28534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28535 }
28536 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 {
28544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28545 }
28546 return resultobj;
28547 fail:
28548 return NULL;
28549 }
28550
28551
28552 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28553 PyObject *resultobj = 0;
28554 wxEventLoop *result = 0 ;
28555
28556 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28557 {
28558 PyThreadState* __tstate = wxPyBeginAllowThreads();
28559 result = (wxEventLoop *)wxEventLoop::GetActive();
28560 wxPyEndAllowThreads(__tstate);
28561 if (PyErr_Occurred()) SWIG_fail;
28562 }
28563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28564 return resultobj;
28565 fail:
28566 return NULL;
28567 }
28568
28569
28570 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28571 PyObject *resultobj = 0;
28572 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28573 void *argp1 = 0 ;
28574 int res1 = 0 ;
28575 PyObject * obj0 = 0 ;
28576 char * kwnames[] = {
28577 (char *) "loop", NULL
28578 };
28579
28580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28582 if (!SWIG_IsOK(res1)) {
28583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28584 }
28585 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28586 {
28587 PyThreadState* __tstate = wxPyBeginAllowThreads();
28588 wxEventLoop::SetActive(arg1);
28589 wxPyEndAllowThreads(__tstate);
28590 if (PyErr_Occurred()) SWIG_fail;
28591 }
28592 resultobj = SWIG_Py_Void();
28593 return resultobj;
28594 fail:
28595 return NULL;
28596 }
28597
28598
28599 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28600 PyObject *obj;
28601 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28602 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28603 return SWIG_Py_Void();
28604 }
28605
28606 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28607 return SWIG_Python_InitShadowInstance(args);
28608 }
28609
28610 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28611 PyObject *resultobj = 0;
28612 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28613 wxEventLoopActivator *result = 0 ;
28614 void *argp1 = 0 ;
28615 int res1 = 0 ;
28616 PyObject * obj0 = 0 ;
28617 char * kwnames[] = {
28618 (char *) "evtLoop", NULL
28619 };
28620
28621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28623 if (!SWIG_IsOK(res1)) {
28624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28625 }
28626 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28627 {
28628 PyThreadState* __tstate = wxPyBeginAllowThreads();
28629 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28630 wxPyEndAllowThreads(__tstate);
28631 if (PyErr_Occurred()) SWIG_fail;
28632 }
28633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28634 return resultobj;
28635 fail:
28636 return NULL;
28637 }
28638
28639
28640 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28641 PyObject *resultobj = 0;
28642 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28643 void *argp1 = 0 ;
28644 int res1 = 0 ;
28645 PyObject *swig_obj[1] ;
28646
28647 if (!args) SWIG_fail;
28648 swig_obj[0] = args;
28649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28650 if (!SWIG_IsOK(res1)) {
28651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28652 }
28653 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28654 {
28655 PyThreadState* __tstate = wxPyBeginAllowThreads();
28656 delete arg1;
28657
28658 wxPyEndAllowThreads(__tstate);
28659 if (PyErr_Occurred()) SWIG_fail;
28660 }
28661 resultobj = SWIG_Py_Void();
28662 return resultobj;
28663 fail:
28664 return NULL;
28665 }
28666
28667
28668 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28669 PyObject *obj;
28670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28671 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28672 return SWIG_Py_Void();
28673 }
28674
28675 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28676 return SWIG_Python_InitShadowInstance(args);
28677 }
28678
28679 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28680 PyObject *resultobj = 0;
28681 int arg1 = (int) 0 ;
28682 int arg2 = (int) 0 ;
28683 int arg3 = (int) 0 ;
28684 wxAcceleratorEntry *result = 0 ;
28685 int val1 ;
28686 int ecode1 = 0 ;
28687 int val2 ;
28688 int ecode2 = 0 ;
28689 int val3 ;
28690 int ecode3 = 0 ;
28691 PyObject * obj0 = 0 ;
28692 PyObject * obj1 = 0 ;
28693 PyObject * obj2 = 0 ;
28694 char * kwnames[] = {
28695 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28696 };
28697
28698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28699 if (obj0) {
28700 ecode1 = SWIG_AsVal_int(obj0, &val1);
28701 if (!SWIG_IsOK(ecode1)) {
28702 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28703 }
28704 arg1 = static_cast< int >(val1);
28705 }
28706 if (obj1) {
28707 ecode2 = SWIG_AsVal_int(obj1, &val2);
28708 if (!SWIG_IsOK(ecode2)) {
28709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28710 }
28711 arg2 = static_cast< int >(val2);
28712 }
28713 if (obj2) {
28714 ecode3 = SWIG_AsVal_int(obj2, &val3);
28715 if (!SWIG_IsOK(ecode3)) {
28716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28717 }
28718 arg3 = static_cast< int >(val3);
28719 }
28720 {
28721 PyThreadState* __tstate = wxPyBeginAllowThreads();
28722 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28723 wxPyEndAllowThreads(__tstate);
28724 if (PyErr_Occurred()) SWIG_fail;
28725 }
28726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28727 return resultobj;
28728 fail:
28729 return NULL;
28730 }
28731
28732
28733 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28734 PyObject *resultobj = 0;
28735 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28736 void *argp1 = 0 ;
28737 int res1 = 0 ;
28738 PyObject *swig_obj[1] ;
28739
28740 if (!args) SWIG_fail;
28741 swig_obj[0] = args;
28742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28743 if (!SWIG_IsOK(res1)) {
28744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28745 }
28746 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28747 {
28748 PyThreadState* __tstate = wxPyBeginAllowThreads();
28749 delete arg1;
28750
28751 wxPyEndAllowThreads(__tstate);
28752 if (PyErr_Occurred()) SWIG_fail;
28753 }
28754 resultobj = SWIG_Py_Void();
28755 return resultobj;
28756 fail:
28757 return NULL;
28758 }
28759
28760
28761 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28762 PyObject *resultobj = 0;
28763 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28764 int arg2 ;
28765 int arg3 ;
28766 int arg4 ;
28767 void *argp1 = 0 ;
28768 int res1 = 0 ;
28769 int val2 ;
28770 int ecode2 = 0 ;
28771 int val3 ;
28772 int ecode3 = 0 ;
28773 int val4 ;
28774 int ecode4 = 0 ;
28775 PyObject * obj0 = 0 ;
28776 PyObject * obj1 = 0 ;
28777 PyObject * obj2 = 0 ;
28778 PyObject * obj3 = 0 ;
28779 char * kwnames[] = {
28780 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28781 };
28782
28783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28785 if (!SWIG_IsOK(res1)) {
28786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28787 }
28788 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28789 ecode2 = SWIG_AsVal_int(obj1, &val2);
28790 if (!SWIG_IsOK(ecode2)) {
28791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28792 }
28793 arg2 = static_cast< int >(val2);
28794 ecode3 = SWIG_AsVal_int(obj2, &val3);
28795 if (!SWIG_IsOK(ecode3)) {
28796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28797 }
28798 arg3 = static_cast< int >(val3);
28799 ecode4 = SWIG_AsVal_int(obj3, &val4);
28800 if (!SWIG_IsOK(ecode4)) {
28801 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28802 }
28803 arg4 = static_cast< int >(val4);
28804 {
28805 PyThreadState* __tstate = wxPyBeginAllowThreads();
28806 (arg1)->Set(arg2,arg3,arg4);
28807 wxPyEndAllowThreads(__tstate);
28808 if (PyErr_Occurred()) SWIG_fail;
28809 }
28810 resultobj = SWIG_Py_Void();
28811 return resultobj;
28812 fail:
28813 return NULL;
28814 }
28815
28816
28817 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28818 PyObject *resultobj = 0;
28819 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28820 int result;
28821 void *argp1 = 0 ;
28822 int res1 = 0 ;
28823 PyObject *swig_obj[1] ;
28824
28825 if (!args) SWIG_fail;
28826 swig_obj[0] = args;
28827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28828 if (!SWIG_IsOK(res1)) {
28829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28830 }
28831 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28832 {
28833 PyThreadState* __tstate = wxPyBeginAllowThreads();
28834 result = (int)(arg1)->GetFlags();
28835 wxPyEndAllowThreads(__tstate);
28836 if (PyErr_Occurred()) SWIG_fail;
28837 }
28838 resultobj = SWIG_From_int(static_cast< int >(result));
28839 return resultobj;
28840 fail:
28841 return NULL;
28842 }
28843
28844
28845 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28846 PyObject *resultobj = 0;
28847 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28848 int result;
28849 void *argp1 = 0 ;
28850 int res1 = 0 ;
28851 PyObject *swig_obj[1] ;
28852
28853 if (!args) SWIG_fail;
28854 swig_obj[0] = args;
28855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28856 if (!SWIG_IsOK(res1)) {
28857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28858 }
28859 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28860 {
28861 PyThreadState* __tstate = wxPyBeginAllowThreads();
28862 result = (int)(arg1)->GetKeyCode();
28863 wxPyEndAllowThreads(__tstate);
28864 if (PyErr_Occurred()) SWIG_fail;
28865 }
28866 resultobj = SWIG_From_int(static_cast< int >(result));
28867 return resultobj;
28868 fail:
28869 return NULL;
28870 }
28871
28872
28873 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28874 PyObject *resultobj = 0;
28875 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28876 int result;
28877 void *argp1 = 0 ;
28878 int res1 = 0 ;
28879 PyObject *swig_obj[1] ;
28880
28881 if (!args) SWIG_fail;
28882 swig_obj[0] = args;
28883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28884 if (!SWIG_IsOK(res1)) {
28885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28886 }
28887 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28888 {
28889 PyThreadState* __tstate = wxPyBeginAllowThreads();
28890 result = (int)(arg1)->GetCommand();
28891 wxPyEndAllowThreads(__tstate);
28892 if (PyErr_Occurred()) SWIG_fail;
28893 }
28894 resultobj = SWIG_From_int(static_cast< int >(result));
28895 return resultobj;
28896 fail:
28897 return NULL;
28898 }
28899
28900
28901 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28902 PyObject *obj;
28903 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28904 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28905 return SWIG_Py_Void();
28906 }
28907
28908 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28909 return SWIG_Python_InitShadowInstance(args);
28910 }
28911
28912 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28913 PyObject *resultobj = 0;
28914 int arg1 ;
28915 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28916 wxAcceleratorTable *result = 0 ;
28917 PyObject * obj0 = 0 ;
28918 char * kwnames[] = {
28919 (char *) "n", NULL
28920 };
28921
28922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28923 {
28924 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28925 if (arg2) arg1 = PyList_Size(obj0);
28926 else arg1 = 0;
28927 }
28928 {
28929 PyThreadState* __tstate = wxPyBeginAllowThreads();
28930 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28931 wxPyEndAllowThreads(__tstate);
28932 if (PyErr_Occurred()) SWIG_fail;
28933 }
28934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
28935 return resultobj;
28936 fail:
28937 return NULL;
28938 }
28939
28940
28941 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28942 PyObject *resultobj = 0;
28943 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28944 void *argp1 = 0 ;
28945 int res1 = 0 ;
28946 PyObject *swig_obj[1] ;
28947
28948 if (!args) SWIG_fail;
28949 swig_obj[0] = args;
28950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
28951 if (!SWIG_IsOK(res1)) {
28952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
28953 }
28954 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28955 {
28956 PyThreadState* __tstate = wxPyBeginAllowThreads();
28957 delete arg1;
28958
28959 wxPyEndAllowThreads(__tstate);
28960 if (PyErr_Occurred()) SWIG_fail;
28961 }
28962 resultobj = SWIG_Py_Void();
28963 return resultobj;
28964 fail:
28965 return NULL;
28966 }
28967
28968
28969 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28970 PyObject *resultobj = 0;
28971 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28972 bool result;
28973 void *argp1 = 0 ;
28974 int res1 = 0 ;
28975 PyObject *swig_obj[1] ;
28976
28977 if (!args) SWIG_fail;
28978 swig_obj[0] = args;
28979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
28980 if (!SWIG_IsOK(res1)) {
28981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
28982 }
28983 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 {
28991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28992 }
28993 return resultobj;
28994 fail:
28995 return NULL;
28996 }
28997
28998
28999 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29000 PyObject *obj;
29001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29002 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29003 return SWIG_Py_Void();
29004 }
29005
29006 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29007 return SWIG_Python_InitShadowInstance(args);
29008 }
29009
29010 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29011 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29012 return 1;
29013 }
29014
29015
29016 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29017 PyObject *pyobj = 0;
29018
29019 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29020 return pyobj;
29021 }
29022
29023
29024 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29025 PyObject *resultobj = 0;
29026 wxString *arg1 = 0 ;
29027 wxAcceleratorEntry *result = 0 ;
29028 bool temp1 = false ;
29029 PyObject * obj0 = 0 ;
29030 char * kwnames[] = {
29031 (char *) "label", NULL
29032 };
29033
29034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29035 {
29036 arg1 = wxString_in_helper(obj0);
29037 if (arg1 == NULL) SWIG_fail;
29038 temp1 = true;
29039 }
29040 {
29041 PyThreadState* __tstate = wxPyBeginAllowThreads();
29042 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29043 wxPyEndAllowThreads(__tstate);
29044 if (PyErr_Occurred()) SWIG_fail;
29045 }
29046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29047 {
29048 if (temp1)
29049 delete arg1;
29050 }
29051 return resultobj;
29052 fail:
29053 {
29054 if (temp1)
29055 delete arg1;
29056 }
29057 return NULL;
29058 }
29059
29060
29061 SWIGINTERN int PanelNameStr_set(PyObject *) {
29062 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29063 return 1;
29064 }
29065
29066
29067 SWIGINTERN PyObject *PanelNameStr_get(void) {
29068 PyObject *pyobj = 0;
29069
29070 {
29071 #if wxUSE_UNICODE
29072 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29073 #else
29074 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29075 #endif
29076 }
29077 return pyobj;
29078 }
29079
29080
29081 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29082 PyObject *resultobj = 0;
29083 wxVisualAttributes *result = 0 ;
29084
29085 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29086 {
29087 PyThreadState* __tstate = wxPyBeginAllowThreads();
29088 result = (wxVisualAttributes *)new_wxVisualAttributes();
29089 wxPyEndAllowThreads(__tstate);
29090 if (PyErr_Occurred()) SWIG_fail;
29091 }
29092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29093 return resultobj;
29094 fail:
29095 return NULL;
29096 }
29097
29098
29099 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29100 PyObject *resultobj = 0;
29101 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29102 void *argp1 = 0 ;
29103 int res1 = 0 ;
29104 PyObject *swig_obj[1] ;
29105
29106 if (!args) SWIG_fail;
29107 swig_obj[0] = args;
29108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29109 if (!SWIG_IsOK(res1)) {
29110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29111 }
29112 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29113 {
29114 PyThreadState* __tstate = wxPyBeginAllowThreads();
29115 delete_wxVisualAttributes(arg1);
29116
29117 wxPyEndAllowThreads(__tstate);
29118 if (PyErr_Occurred()) SWIG_fail;
29119 }
29120 resultobj = SWIG_Py_Void();
29121 return resultobj;
29122 fail:
29123 return NULL;
29124 }
29125
29126
29127 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29128 PyObject *resultobj = 0;
29129 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29130 wxFont *arg2 = (wxFont *) 0 ;
29131 void *argp1 = 0 ;
29132 int res1 = 0 ;
29133 void *argp2 = 0 ;
29134 int res2 = 0 ;
29135 PyObject *swig_obj[2] ;
29136
29137 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29139 if (!SWIG_IsOK(res1)) {
29140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29141 }
29142 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29143 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29144 if (!SWIG_IsOK(res2)) {
29145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29146 }
29147 arg2 = reinterpret_cast< wxFont * >(argp2);
29148 if (arg1) (arg1)->font = *arg2;
29149
29150 resultobj = SWIG_Py_Void();
29151 return resultobj;
29152 fail:
29153 return NULL;
29154 }
29155
29156
29157 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29158 PyObject *resultobj = 0;
29159 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29160 wxFont *result = 0 ;
29161 void *argp1 = 0 ;
29162 int res1 = 0 ;
29163 PyObject *swig_obj[1] ;
29164
29165 if (!args) SWIG_fail;
29166 swig_obj[0] = args;
29167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29168 if (!SWIG_IsOK(res1)) {
29169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29170 }
29171 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29172 result = (wxFont *)& ((arg1)->font);
29173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29174 return resultobj;
29175 fail:
29176 return NULL;
29177 }
29178
29179
29180 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29181 PyObject *resultobj = 0;
29182 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29183 wxColour *arg2 = (wxColour *) 0 ;
29184 void *argp1 = 0 ;
29185 int res1 = 0 ;
29186 void *argp2 = 0 ;
29187 int res2 = 0 ;
29188 PyObject *swig_obj[2] ;
29189
29190 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29192 if (!SWIG_IsOK(res1)) {
29193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29194 }
29195 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29196 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29197 if (!SWIG_IsOK(res2)) {
29198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29199 }
29200 arg2 = reinterpret_cast< wxColour * >(argp2);
29201 if (arg1) (arg1)->colFg = *arg2;
29202
29203 resultobj = SWIG_Py_Void();
29204 return resultobj;
29205 fail:
29206 return NULL;
29207 }
29208
29209
29210 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29211 PyObject *resultobj = 0;
29212 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29213 wxColour *result = 0 ;
29214 void *argp1 = 0 ;
29215 int res1 = 0 ;
29216 PyObject *swig_obj[1] ;
29217
29218 if (!args) SWIG_fail;
29219 swig_obj[0] = args;
29220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29221 if (!SWIG_IsOK(res1)) {
29222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29223 }
29224 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29225 result = (wxColour *)& ((arg1)->colFg);
29226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29227 return resultobj;
29228 fail:
29229 return NULL;
29230 }
29231
29232
29233 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29234 PyObject *resultobj = 0;
29235 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29236 wxColour *arg2 = (wxColour *) 0 ;
29237 void *argp1 = 0 ;
29238 int res1 = 0 ;
29239 void *argp2 = 0 ;
29240 int res2 = 0 ;
29241 PyObject *swig_obj[2] ;
29242
29243 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29245 if (!SWIG_IsOK(res1)) {
29246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29247 }
29248 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29249 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29250 if (!SWIG_IsOK(res2)) {
29251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29252 }
29253 arg2 = reinterpret_cast< wxColour * >(argp2);
29254 if (arg1) (arg1)->colBg = *arg2;
29255
29256 resultobj = SWIG_Py_Void();
29257 return resultobj;
29258 fail:
29259 return NULL;
29260 }
29261
29262
29263 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29264 PyObject *resultobj = 0;
29265 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29266 wxColour *result = 0 ;
29267 void *argp1 = 0 ;
29268 int res1 = 0 ;
29269 PyObject *swig_obj[1] ;
29270
29271 if (!args) SWIG_fail;
29272 swig_obj[0] = args;
29273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29274 if (!SWIG_IsOK(res1)) {
29275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29276 }
29277 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29278 result = (wxColour *)& ((arg1)->colBg);
29279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29280 return resultobj;
29281 fail:
29282 return NULL;
29283 }
29284
29285
29286 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29287 PyObject *obj;
29288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29289 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29290 return SWIG_Py_Void();
29291 }
29292
29293 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29294 return SWIG_Python_InitShadowInstance(args);
29295 }
29296
29297 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29298 PyObject *resultobj = 0;
29299 wxWindow *arg1 = (wxWindow *) 0 ;
29300 int arg2 = (int) (int)-1 ;
29301 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29302 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29303 wxSize const &arg4_defvalue = wxDefaultSize ;
29304 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29305 long arg5 = (long) 0 ;
29306 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29307 wxString *arg6 = (wxString *) &arg6_defvalue ;
29308 wxWindow *result = 0 ;
29309 void *argp1 = 0 ;
29310 int res1 = 0 ;
29311 int val2 ;
29312 int ecode2 = 0 ;
29313 wxPoint temp3 ;
29314 wxSize temp4 ;
29315 long val5 ;
29316 int ecode5 = 0 ;
29317 bool temp6 = false ;
29318 PyObject * obj0 = 0 ;
29319 PyObject * obj1 = 0 ;
29320 PyObject * obj2 = 0 ;
29321 PyObject * obj3 = 0 ;
29322 PyObject * obj4 = 0 ;
29323 PyObject * obj5 = 0 ;
29324 char * kwnames[] = {
29325 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29326 };
29327
29328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29330 if (!SWIG_IsOK(res1)) {
29331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29332 }
29333 arg1 = reinterpret_cast< wxWindow * >(argp1);
29334 if (obj1) {
29335 ecode2 = SWIG_AsVal_int(obj1, &val2);
29336 if (!SWIG_IsOK(ecode2)) {
29337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29338 }
29339 arg2 = static_cast< int >(val2);
29340 }
29341 if (obj2) {
29342 {
29343 arg3 = &temp3;
29344 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29345 }
29346 }
29347 if (obj3) {
29348 {
29349 arg4 = &temp4;
29350 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29351 }
29352 }
29353 if (obj4) {
29354 ecode5 = SWIG_AsVal_long(obj4, &val5);
29355 if (!SWIG_IsOK(ecode5)) {
29356 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29357 }
29358 arg5 = static_cast< long >(val5);
29359 }
29360 if (obj5) {
29361 {
29362 arg6 = wxString_in_helper(obj5);
29363 if (arg6 == NULL) SWIG_fail;
29364 temp6 = true;
29365 }
29366 }
29367 {
29368 if (!wxPyCheckForApp()) SWIG_fail;
29369 PyThreadState* __tstate = wxPyBeginAllowThreads();
29370 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29371 wxPyEndAllowThreads(__tstate);
29372 if (PyErr_Occurred()) SWIG_fail;
29373 }
29374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29375 {
29376 if (temp6)
29377 delete arg6;
29378 }
29379 return resultobj;
29380 fail:
29381 {
29382 if (temp6)
29383 delete arg6;
29384 }
29385 return NULL;
29386 }
29387
29388
29389 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29390 PyObject *resultobj = 0;
29391 wxWindow *result = 0 ;
29392
29393 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29394 {
29395 if (!wxPyCheckForApp()) SWIG_fail;
29396 PyThreadState* __tstate = wxPyBeginAllowThreads();
29397 result = (wxWindow *)new wxWindow();
29398 wxPyEndAllowThreads(__tstate);
29399 if (PyErr_Occurred()) SWIG_fail;
29400 }
29401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29402 return resultobj;
29403 fail:
29404 return NULL;
29405 }
29406
29407
29408 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29409 PyObject *resultobj = 0;
29410 wxWindow *arg1 = (wxWindow *) 0 ;
29411 wxWindow *arg2 = (wxWindow *) 0 ;
29412 int arg3 = (int) (int)-1 ;
29413 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29414 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29415 wxSize const &arg5_defvalue = wxDefaultSize ;
29416 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29417 long arg6 = (long) 0 ;
29418 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29419 wxString *arg7 = (wxString *) &arg7_defvalue ;
29420 bool result;
29421 void *argp1 = 0 ;
29422 int res1 = 0 ;
29423 void *argp2 = 0 ;
29424 int res2 = 0 ;
29425 int val3 ;
29426 int ecode3 = 0 ;
29427 wxPoint temp4 ;
29428 wxSize temp5 ;
29429 long val6 ;
29430 int ecode6 = 0 ;
29431 bool temp7 = false ;
29432 PyObject * obj0 = 0 ;
29433 PyObject * obj1 = 0 ;
29434 PyObject * obj2 = 0 ;
29435 PyObject * obj3 = 0 ;
29436 PyObject * obj4 = 0 ;
29437 PyObject * obj5 = 0 ;
29438 PyObject * obj6 = 0 ;
29439 char * kwnames[] = {
29440 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29441 };
29442
29443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29445 if (!SWIG_IsOK(res1)) {
29446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29447 }
29448 arg1 = reinterpret_cast< wxWindow * >(argp1);
29449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29450 if (!SWIG_IsOK(res2)) {
29451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29452 }
29453 arg2 = reinterpret_cast< wxWindow * >(argp2);
29454 if (obj2) {
29455 ecode3 = SWIG_AsVal_int(obj2, &val3);
29456 if (!SWIG_IsOK(ecode3)) {
29457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29458 }
29459 arg3 = static_cast< int >(val3);
29460 }
29461 if (obj3) {
29462 {
29463 arg4 = &temp4;
29464 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29465 }
29466 }
29467 if (obj4) {
29468 {
29469 arg5 = &temp5;
29470 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29471 }
29472 }
29473 if (obj5) {
29474 ecode6 = SWIG_AsVal_long(obj5, &val6);
29475 if (!SWIG_IsOK(ecode6)) {
29476 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29477 }
29478 arg6 = static_cast< long >(val6);
29479 }
29480 if (obj6) {
29481 {
29482 arg7 = wxString_in_helper(obj6);
29483 if (arg7 == NULL) SWIG_fail;
29484 temp7 = true;
29485 }
29486 }
29487 {
29488 PyThreadState* __tstate = wxPyBeginAllowThreads();
29489 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29490 wxPyEndAllowThreads(__tstate);
29491 if (PyErr_Occurred()) SWIG_fail;
29492 }
29493 {
29494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29495 }
29496 {
29497 if (temp7)
29498 delete arg7;
29499 }
29500 return resultobj;
29501 fail:
29502 {
29503 if (temp7)
29504 delete arg7;
29505 }
29506 return NULL;
29507 }
29508
29509
29510 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29511 PyObject *resultobj = 0;
29512 wxWindow *arg1 = (wxWindow *) 0 ;
29513 bool arg2 = (bool) false ;
29514 bool result;
29515 void *argp1 = 0 ;
29516 int res1 = 0 ;
29517 bool val2 ;
29518 int ecode2 = 0 ;
29519 PyObject * obj0 = 0 ;
29520 PyObject * obj1 = 0 ;
29521 char * kwnames[] = {
29522 (char *) "self",(char *) "force", NULL
29523 };
29524
29525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29527 if (!SWIG_IsOK(res1)) {
29528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29529 }
29530 arg1 = reinterpret_cast< wxWindow * >(argp1);
29531 if (obj1) {
29532 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29533 if (!SWIG_IsOK(ecode2)) {
29534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29535 }
29536 arg2 = static_cast< bool >(val2);
29537 }
29538 {
29539 PyThreadState* __tstate = wxPyBeginAllowThreads();
29540 result = (bool)(arg1)->Close(arg2);
29541 wxPyEndAllowThreads(__tstate);
29542 if (PyErr_Occurred()) SWIG_fail;
29543 }
29544 {
29545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29546 }
29547 return resultobj;
29548 fail:
29549 return NULL;
29550 }
29551
29552
29553 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29554 PyObject *resultobj = 0;
29555 wxWindow *arg1 = (wxWindow *) 0 ;
29556 bool result;
29557 void *argp1 = 0 ;
29558 int res1 = 0 ;
29559 PyObject *swig_obj[1] ;
29560
29561 if (!args) SWIG_fail;
29562 swig_obj[0] = args;
29563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29564 if (!SWIG_IsOK(res1)) {
29565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29566 }
29567 arg1 = reinterpret_cast< wxWindow * >(argp1);
29568 {
29569 PyThreadState* __tstate = wxPyBeginAllowThreads();
29570 result = (bool)(arg1)->Destroy();
29571 wxPyEndAllowThreads(__tstate);
29572 if (PyErr_Occurred()) SWIG_fail;
29573 }
29574 {
29575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29576 }
29577 return resultobj;
29578 fail:
29579 return NULL;
29580 }
29581
29582
29583 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29584 PyObject *resultobj = 0;
29585 wxWindow *arg1 = (wxWindow *) 0 ;
29586 bool result;
29587 void *argp1 = 0 ;
29588 int res1 = 0 ;
29589 PyObject *swig_obj[1] ;
29590
29591 if (!args) SWIG_fail;
29592 swig_obj[0] = args;
29593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29594 if (!SWIG_IsOK(res1)) {
29595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29596 }
29597 arg1 = reinterpret_cast< wxWindow * >(argp1);
29598 {
29599 PyThreadState* __tstate = wxPyBeginAllowThreads();
29600 result = (bool)(arg1)->DestroyChildren();
29601 wxPyEndAllowThreads(__tstate);
29602 if (PyErr_Occurred()) SWIG_fail;
29603 }
29604 {
29605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29606 }
29607 return resultobj;
29608 fail:
29609 return NULL;
29610 }
29611
29612
29613 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29614 PyObject *resultobj = 0;
29615 wxWindow *arg1 = (wxWindow *) 0 ;
29616 bool result;
29617 void *argp1 = 0 ;
29618 int res1 = 0 ;
29619 PyObject *swig_obj[1] ;
29620
29621 if (!args) SWIG_fail;
29622 swig_obj[0] = args;
29623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29624 if (!SWIG_IsOK(res1)) {
29625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29626 }
29627 arg1 = reinterpret_cast< wxWindow * >(argp1);
29628 {
29629 PyThreadState* __tstate = wxPyBeginAllowThreads();
29630 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29631 wxPyEndAllowThreads(__tstate);
29632 if (PyErr_Occurred()) SWIG_fail;
29633 }
29634 {
29635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29636 }
29637 return resultobj;
29638 fail:
29639 return NULL;
29640 }
29641
29642
29643 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29644 PyObject *resultobj = 0;
29645 wxWindow *arg1 = (wxWindow *) 0 ;
29646 wxString *arg2 = 0 ;
29647 void *argp1 = 0 ;
29648 int res1 = 0 ;
29649 bool temp2 = false ;
29650 PyObject * obj0 = 0 ;
29651 PyObject * obj1 = 0 ;
29652 char * kwnames[] = {
29653 (char *) "self",(char *) "label", NULL
29654 };
29655
29656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29658 if (!SWIG_IsOK(res1)) {
29659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29660 }
29661 arg1 = reinterpret_cast< wxWindow * >(argp1);
29662 {
29663 arg2 = wxString_in_helper(obj1);
29664 if (arg2 == NULL) SWIG_fail;
29665 temp2 = true;
29666 }
29667 {
29668 PyThreadState* __tstate = wxPyBeginAllowThreads();
29669 (arg1)->SetLabel((wxString const &)*arg2);
29670 wxPyEndAllowThreads(__tstate);
29671 if (PyErr_Occurred()) SWIG_fail;
29672 }
29673 resultobj = SWIG_Py_Void();
29674 {
29675 if (temp2)
29676 delete arg2;
29677 }
29678 return resultobj;
29679 fail:
29680 {
29681 if (temp2)
29682 delete arg2;
29683 }
29684 return NULL;
29685 }
29686
29687
29688 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29689 PyObject *resultobj = 0;
29690 wxWindow *arg1 = (wxWindow *) 0 ;
29691 wxString result;
29692 void *argp1 = 0 ;
29693 int res1 = 0 ;
29694 PyObject *swig_obj[1] ;
29695
29696 if (!args) SWIG_fail;
29697 swig_obj[0] = args;
29698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29699 if (!SWIG_IsOK(res1)) {
29700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29701 }
29702 arg1 = reinterpret_cast< wxWindow * >(argp1);
29703 {
29704 PyThreadState* __tstate = wxPyBeginAllowThreads();
29705 result = ((wxWindow const *)arg1)->GetLabel();
29706 wxPyEndAllowThreads(__tstate);
29707 if (PyErr_Occurred()) SWIG_fail;
29708 }
29709 {
29710 #if wxUSE_UNICODE
29711 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29712 #else
29713 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29714 #endif
29715 }
29716 return resultobj;
29717 fail:
29718 return NULL;
29719 }
29720
29721
29722 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29723 PyObject *resultobj = 0;
29724 wxWindow *arg1 = (wxWindow *) 0 ;
29725 wxString *arg2 = 0 ;
29726 void *argp1 = 0 ;
29727 int res1 = 0 ;
29728 bool temp2 = false ;
29729 PyObject * obj0 = 0 ;
29730 PyObject * obj1 = 0 ;
29731 char * kwnames[] = {
29732 (char *) "self",(char *) "name", NULL
29733 };
29734
29735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29737 if (!SWIG_IsOK(res1)) {
29738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29739 }
29740 arg1 = reinterpret_cast< wxWindow * >(argp1);
29741 {
29742 arg2 = wxString_in_helper(obj1);
29743 if (arg2 == NULL) SWIG_fail;
29744 temp2 = true;
29745 }
29746 {
29747 PyThreadState* __tstate = wxPyBeginAllowThreads();
29748 (arg1)->SetName((wxString const &)*arg2);
29749 wxPyEndAllowThreads(__tstate);
29750 if (PyErr_Occurred()) SWIG_fail;
29751 }
29752 resultobj = SWIG_Py_Void();
29753 {
29754 if (temp2)
29755 delete arg2;
29756 }
29757 return resultobj;
29758 fail:
29759 {
29760 if (temp2)
29761 delete arg2;
29762 }
29763 return NULL;
29764 }
29765
29766
29767 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29768 PyObject *resultobj = 0;
29769 wxWindow *arg1 = (wxWindow *) 0 ;
29770 wxString result;
29771 void *argp1 = 0 ;
29772 int res1 = 0 ;
29773 PyObject *swig_obj[1] ;
29774
29775 if (!args) SWIG_fail;
29776 swig_obj[0] = args;
29777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29778 if (!SWIG_IsOK(res1)) {
29779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29780 }
29781 arg1 = reinterpret_cast< wxWindow * >(argp1);
29782 {
29783 PyThreadState* __tstate = wxPyBeginAllowThreads();
29784 result = ((wxWindow const *)arg1)->GetName();
29785 wxPyEndAllowThreads(__tstate);
29786 if (PyErr_Occurred()) SWIG_fail;
29787 }
29788 {
29789 #if wxUSE_UNICODE
29790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29791 #else
29792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29793 #endif
29794 }
29795 return resultobj;
29796 fail:
29797 return NULL;
29798 }
29799
29800
29801 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29802 PyObject *resultobj = 0;
29803 wxWindow *arg1 = (wxWindow *) 0 ;
29804 wxWindowVariant arg2 ;
29805 void *argp1 = 0 ;
29806 int res1 = 0 ;
29807 int val2 ;
29808 int ecode2 = 0 ;
29809 PyObject * obj0 = 0 ;
29810 PyObject * obj1 = 0 ;
29811 char * kwnames[] = {
29812 (char *) "self",(char *) "variant", NULL
29813 };
29814
29815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29817 if (!SWIG_IsOK(res1)) {
29818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29819 }
29820 arg1 = reinterpret_cast< wxWindow * >(argp1);
29821 ecode2 = SWIG_AsVal_int(obj1, &val2);
29822 if (!SWIG_IsOK(ecode2)) {
29823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29824 }
29825 arg2 = static_cast< wxWindowVariant >(val2);
29826 {
29827 PyThreadState* __tstate = wxPyBeginAllowThreads();
29828 (arg1)->SetWindowVariant(arg2);
29829 wxPyEndAllowThreads(__tstate);
29830 if (PyErr_Occurred()) SWIG_fail;
29831 }
29832 resultobj = SWIG_Py_Void();
29833 return resultobj;
29834 fail:
29835 return NULL;
29836 }
29837
29838
29839 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29840 PyObject *resultobj = 0;
29841 wxWindow *arg1 = (wxWindow *) 0 ;
29842 wxWindowVariant result;
29843 void *argp1 = 0 ;
29844 int res1 = 0 ;
29845 PyObject *swig_obj[1] ;
29846
29847 if (!args) SWIG_fail;
29848 swig_obj[0] = args;
29849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29850 if (!SWIG_IsOK(res1)) {
29851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29852 }
29853 arg1 = reinterpret_cast< wxWindow * >(argp1);
29854 {
29855 PyThreadState* __tstate = wxPyBeginAllowThreads();
29856 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29857 wxPyEndAllowThreads(__tstate);
29858 if (PyErr_Occurred()) SWIG_fail;
29859 }
29860 resultobj = SWIG_From_int(static_cast< int >(result));
29861 return resultobj;
29862 fail:
29863 return NULL;
29864 }
29865
29866
29867 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29868 PyObject *resultobj = 0;
29869 wxWindow *arg1 = (wxWindow *) 0 ;
29870 int arg2 ;
29871 void *argp1 = 0 ;
29872 int res1 = 0 ;
29873 int val2 ;
29874 int ecode2 = 0 ;
29875 PyObject * obj0 = 0 ;
29876 PyObject * obj1 = 0 ;
29877 char * kwnames[] = {
29878 (char *) "self",(char *) "winid", NULL
29879 };
29880
29881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29883 if (!SWIG_IsOK(res1)) {
29884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29885 }
29886 arg1 = reinterpret_cast< wxWindow * >(argp1);
29887 ecode2 = SWIG_AsVal_int(obj1, &val2);
29888 if (!SWIG_IsOK(ecode2)) {
29889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29890 }
29891 arg2 = static_cast< int >(val2);
29892 {
29893 PyThreadState* __tstate = wxPyBeginAllowThreads();
29894 (arg1)->SetId(arg2);
29895 wxPyEndAllowThreads(__tstate);
29896 if (PyErr_Occurred()) SWIG_fail;
29897 }
29898 resultobj = SWIG_Py_Void();
29899 return resultobj;
29900 fail:
29901 return NULL;
29902 }
29903
29904
29905 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29906 PyObject *resultobj = 0;
29907 wxWindow *arg1 = (wxWindow *) 0 ;
29908 int result;
29909 void *argp1 = 0 ;
29910 int res1 = 0 ;
29911 PyObject *swig_obj[1] ;
29912
29913 if (!args) SWIG_fail;
29914 swig_obj[0] = args;
29915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29916 if (!SWIG_IsOK(res1)) {
29917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29918 }
29919 arg1 = reinterpret_cast< wxWindow * >(argp1);
29920 {
29921 PyThreadState* __tstate = wxPyBeginAllowThreads();
29922 result = (int)((wxWindow const *)arg1)->GetId();
29923 wxPyEndAllowThreads(__tstate);
29924 if (PyErr_Occurred()) SWIG_fail;
29925 }
29926 resultobj = SWIG_From_int(static_cast< int >(result));
29927 return resultobj;
29928 fail:
29929 return NULL;
29930 }
29931
29932
29933 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29934 PyObject *resultobj = 0;
29935 int result;
29936
29937 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
29938 {
29939 PyThreadState* __tstate = wxPyBeginAllowThreads();
29940 result = (int)wxWindow::NewControlId();
29941 wxPyEndAllowThreads(__tstate);
29942 if (PyErr_Occurred()) SWIG_fail;
29943 }
29944 resultobj = SWIG_From_int(static_cast< int >(result));
29945 return resultobj;
29946 fail:
29947 return NULL;
29948 }
29949
29950
29951 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29952 PyObject *resultobj = 0;
29953 int arg1 ;
29954 int result;
29955 int val1 ;
29956 int ecode1 = 0 ;
29957 PyObject * obj0 = 0 ;
29958 char * kwnames[] = {
29959 (char *) "winid", NULL
29960 };
29961
29962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
29963 ecode1 = SWIG_AsVal_int(obj0, &val1);
29964 if (!SWIG_IsOK(ecode1)) {
29965 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
29966 }
29967 arg1 = static_cast< int >(val1);
29968 {
29969 PyThreadState* __tstate = wxPyBeginAllowThreads();
29970 result = (int)wxWindow::NextControlId(arg1);
29971 wxPyEndAllowThreads(__tstate);
29972 if (PyErr_Occurred()) SWIG_fail;
29973 }
29974 resultobj = SWIG_From_int(static_cast< int >(result));
29975 return resultobj;
29976 fail:
29977 return NULL;
29978 }
29979
29980
29981 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29982 PyObject *resultobj = 0;
29983 int arg1 ;
29984 int result;
29985 int val1 ;
29986 int ecode1 = 0 ;
29987 PyObject * obj0 = 0 ;
29988 char * kwnames[] = {
29989 (char *) "winid", NULL
29990 };
29991
29992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
29993 ecode1 = SWIG_AsVal_int(obj0, &val1);
29994 if (!SWIG_IsOK(ecode1)) {
29995 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
29996 }
29997 arg1 = static_cast< int >(val1);
29998 {
29999 PyThreadState* __tstate = wxPyBeginAllowThreads();
30000 result = (int)wxWindow::PrevControlId(arg1);
30001 wxPyEndAllowThreads(__tstate);
30002 if (PyErr_Occurred()) SWIG_fail;
30003 }
30004 resultobj = SWIG_From_int(static_cast< int >(result));
30005 return resultobj;
30006 fail:
30007 return NULL;
30008 }
30009
30010
30011 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30012 PyObject *resultobj = 0;
30013 wxWindow *arg1 = (wxWindow *) 0 ;
30014 wxSize *arg2 = 0 ;
30015 void *argp1 = 0 ;
30016 int res1 = 0 ;
30017 wxSize temp2 ;
30018 PyObject * obj0 = 0 ;
30019 PyObject * obj1 = 0 ;
30020 char * kwnames[] = {
30021 (char *) "self",(char *) "size", NULL
30022 };
30023
30024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30026 if (!SWIG_IsOK(res1)) {
30027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30028 }
30029 arg1 = reinterpret_cast< wxWindow * >(argp1);
30030 {
30031 arg2 = &temp2;
30032 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30033 }
30034 {
30035 PyThreadState* __tstate = wxPyBeginAllowThreads();
30036 (arg1)->SetSize((wxSize const &)*arg2);
30037 wxPyEndAllowThreads(__tstate);
30038 if (PyErr_Occurred()) SWIG_fail;
30039 }
30040 resultobj = SWIG_Py_Void();
30041 return resultobj;
30042 fail:
30043 return NULL;
30044 }
30045
30046
30047 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30048 PyObject *resultobj = 0;
30049 wxWindow *arg1 = (wxWindow *) 0 ;
30050 int arg2 ;
30051 int arg3 ;
30052 int arg4 ;
30053 int arg5 ;
30054 int arg6 = (int) wxSIZE_AUTO ;
30055 void *argp1 = 0 ;
30056 int res1 = 0 ;
30057 int val2 ;
30058 int ecode2 = 0 ;
30059 int val3 ;
30060 int ecode3 = 0 ;
30061 int val4 ;
30062 int ecode4 = 0 ;
30063 int val5 ;
30064 int ecode5 = 0 ;
30065 int val6 ;
30066 int ecode6 = 0 ;
30067 PyObject * obj0 = 0 ;
30068 PyObject * obj1 = 0 ;
30069 PyObject * obj2 = 0 ;
30070 PyObject * obj3 = 0 ;
30071 PyObject * obj4 = 0 ;
30072 PyObject * obj5 = 0 ;
30073 char * kwnames[] = {
30074 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30075 };
30076
30077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30079 if (!SWIG_IsOK(res1)) {
30080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30081 }
30082 arg1 = reinterpret_cast< wxWindow * >(argp1);
30083 ecode2 = SWIG_AsVal_int(obj1, &val2);
30084 if (!SWIG_IsOK(ecode2)) {
30085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30086 }
30087 arg2 = static_cast< int >(val2);
30088 ecode3 = SWIG_AsVal_int(obj2, &val3);
30089 if (!SWIG_IsOK(ecode3)) {
30090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30091 }
30092 arg3 = static_cast< int >(val3);
30093 ecode4 = SWIG_AsVal_int(obj3, &val4);
30094 if (!SWIG_IsOK(ecode4)) {
30095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30096 }
30097 arg4 = static_cast< int >(val4);
30098 ecode5 = SWIG_AsVal_int(obj4, &val5);
30099 if (!SWIG_IsOK(ecode5)) {
30100 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30101 }
30102 arg5 = static_cast< int >(val5);
30103 if (obj5) {
30104 ecode6 = SWIG_AsVal_int(obj5, &val6);
30105 if (!SWIG_IsOK(ecode6)) {
30106 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30107 }
30108 arg6 = static_cast< int >(val6);
30109 }
30110 {
30111 PyThreadState* __tstate = wxPyBeginAllowThreads();
30112 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30113 wxPyEndAllowThreads(__tstate);
30114 if (PyErr_Occurred()) SWIG_fail;
30115 }
30116 resultobj = SWIG_Py_Void();
30117 return resultobj;
30118 fail:
30119 return NULL;
30120 }
30121
30122
30123 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30124 PyObject *resultobj = 0;
30125 wxWindow *arg1 = (wxWindow *) 0 ;
30126 wxRect *arg2 = 0 ;
30127 int arg3 = (int) wxSIZE_AUTO ;
30128 void *argp1 = 0 ;
30129 int res1 = 0 ;
30130 wxRect temp2 ;
30131 int val3 ;
30132 int ecode3 = 0 ;
30133 PyObject * obj0 = 0 ;
30134 PyObject * obj1 = 0 ;
30135 PyObject * obj2 = 0 ;
30136 char * kwnames[] = {
30137 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30138 };
30139
30140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30142 if (!SWIG_IsOK(res1)) {
30143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30144 }
30145 arg1 = reinterpret_cast< wxWindow * >(argp1);
30146 {
30147 arg2 = &temp2;
30148 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30149 }
30150 if (obj2) {
30151 ecode3 = SWIG_AsVal_int(obj2, &val3);
30152 if (!SWIG_IsOK(ecode3)) {
30153 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30154 }
30155 arg3 = static_cast< int >(val3);
30156 }
30157 {
30158 PyThreadState* __tstate = wxPyBeginAllowThreads();
30159 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30160 wxPyEndAllowThreads(__tstate);
30161 if (PyErr_Occurred()) SWIG_fail;
30162 }
30163 resultobj = SWIG_Py_Void();
30164 return resultobj;
30165 fail:
30166 return NULL;
30167 }
30168
30169
30170 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30171 PyObject *resultobj = 0;
30172 wxWindow *arg1 = (wxWindow *) 0 ;
30173 int arg2 ;
30174 int arg3 ;
30175 void *argp1 = 0 ;
30176 int res1 = 0 ;
30177 int val2 ;
30178 int ecode2 = 0 ;
30179 int val3 ;
30180 int ecode3 = 0 ;
30181 PyObject * obj0 = 0 ;
30182 PyObject * obj1 = 0 ;
30183 PyObject * obj2 = 0 ;
30184 char * kwnames[] = {
30185 (char *) "self",(char *) "width",(char *) "height", NULL
30186 };
30187
30188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30190 if (!SWIG_IsOK(res1)) {
30191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30192 }
30193 arg1 = reinterpret_cast< wxWindow * >(argp1);
30194 ecode2 = SWIG_AsVal_int(obj1, &val2);
30195 if (!SWIG_IsOK(ecode2)) {
30196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30197 }
30198 arg2 = static_cast< int >(val2);
30199 ecode3 = SWIG_AsVal_int(obj2, &val3);
30200 if (!SWIG_IsOK(ecode3)) {
30201 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30202 }
30203 arg3 = static_cast< int >(val3);
30204 {
30205 PyThreadState* __tstate = wxPyBeginAllowThreads();
30206 (arg1)->SetSize(arg2,arg3);
30207 wxPyEndAllowThreads(__tstate);
30208 if (PyErr_Occurred()) SWIG_fail;
30209 }
30210 resultobj = SWIG_Py_Void();
30211 return resultobj;
30212 fail:
30213 return NULL;
30214 }
30215
30216
30217 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30218 PyObject *resultobj = 0;
30219 wxWindow *arg1 = (wxWindow *) 0 ;
30220 wxPoint *arg2 = 0 ;
30221 int arg3 = (int) wxSIZE_USE_EXISTING ;
30222 void *argp1 = 0 ;
30223 int res1 = 0 ;
30224 wxPoint temp2 ;
30225 int val3 ;
30226 int ecode3 = 0 ;
30227 PyObject * obj0 = 0 ;
30228 PyObject * obj1 = 0 ;
30229 PyObject * obj2 = 0 ;
30230 char * kwnames[] = {
30231 (char *) "self",(char *) "pt",(char *) "flags", NULL
30232 };
30233
30234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30236 if (!SWIG_IsOK(res1)) {
30237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30238 }
30239 arg1 = reinterpret_cast< wxWindow * >(argp1);
30240 {
30241 arg2 = &temp2;
30242 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30243 }
30244 if (obj2) {
30245 ecode3 = SWIG_AsVal_int(obj2, &val3);
30246 if (!SWIG_IsOK(ecode3)) {
30247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30248 }
30249 arg3 = static_cast< int >(val3);
30250 }
30251 {
30252 PyThreadState* __tstate = wxPyBeginAllowThreads();
30253 (arg1)->Move((wxPoint const &)*arg2,arg3);
30254 wxPyEndAllowThreads(__tstate);
30255 if (PyErr_Occurred()) SWIG_fail;
30256 }
30257 resultobj = SWIG_Py_Void();
30258 return resultobj;
30259 fail:
30260 return NULL;
30261 }
30262
30263
30264 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30265 PyObject *resultobj = 0;
30266 wxWindow *arg1 = (wxWindow *) 0 ;
30267 int arg2 ;
30268 int arg3 ;
30269 int arg4 = (int) wxSIZE_USE_EXISTING ;
30270 void *argp1 = 0 ;
30271 int res1 = 0 ;
30272 int val2 ;
30273 int ecode2 = 0 ;
30274 int val3 ;
30275 int ecode3 = 0 ;
30276 int val4 ;
30277 int ecode4 = 0 ;
30278 PyObject * obj0 = 0 ;
30279 PyObject * obj1 = 0 ;
30280 PyObject * obj2 = 0 ;
30281 PyObject * obj3 = 0 ;
30282 char * kwnames[] = {
30283 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30284 };
30285
30286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30290 }
30291 arg1 = reinterpret_cast< wxWindow * >(argp1);
30292 ecode2 = SWIG_AsVal_int(obj1, &val2);
30293 if (!SWIG_IsOK(ecode2)) {
30294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30295 }
30296 arg2 = static_cast< int >(val2);
30297 ecode3 = SWIG_AsVal_int(obj2, &val3);
30298 if (!SWIG_IsOK(ecode3)) {
30299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30300 }
30301 arg3 = static_cast< int >(val3);
30302 if (obj3) {
30303 ecode4 = SWIG_AsVal_int(obj3, &val4);
30304 if (!SWIG_IsOK(ecode4)) {
30305 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30306 }
30307 arg4 = static_cast< int >(val4);
30308 }
30309 {
30310 PyThreadState* __tstate = wxPyBeginAllowThreads();
30311 (arg1)->Move(arg2,arg3,arg4);
30312 wxPyEndAllowThreads(__tstate);
30313 if (PyErr_Occurred()) SWIG_fail;
30314 }
30315 resultobj = SWIG_Py_Void();
30316 return resultobj;
30317 fail:
30318 return NULL;
30319 }
30320
30321
30322 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30323 PyObject *resultobj = 0;
30324 wxWindow *arg1 = (wxWindow *) 0 ;
30325 wxSize const &arg2_defvalue = wxDefaultSize ;
30326 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30327 void *argp1 = 0 ;
30328 int res1 = 0 ;
30329 wxSize temp2 ;
30330 PyObject * obj0 = 0 ;
30331 PyObject * obj1 = 0 ;
30332 char * kwnames[] = {
30333 (char *) "self",(char *) "size", NULL
30334 };
30335
30336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30338 if (!SWIG_IsOK(res1)) {
30339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30340 }
30341 arg1 = reinterpret_cast< wxWindow * >(argp1);
30342 if (obj1) {
30343 {
30344 arg2 = &temp2;
30345 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30346 }
30347 }
30348 {
30349 PyThreadState* __tstate = wxPyBeginAllowThreads();
30350 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30351 wxPyEndAllowThreads(__tstate);
30352 if (PyErr_Occurred()) SWIG_fail;
30353 }
30354 resultobj = SWIG_Py_Void();
30355 return resultobj;
30356 fail:
30357 return NULL;
30358 }
30359
30360
30361 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30362 PyObject *resultobj = 0;
30363 wxWindow *arg1 = (wxWindow *) 0 ;
30364 void *argp1 = 0 ;
30365 int res1 = 0 ;
30366 PyObject *swig_obj[1] ;
30367
30368 if (!args) SWIG_fail;
30369 swig_obj[0] = args;
30370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30371 if (!SWIG_IsOK(res1)) {
30372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30373 }
30374 arg1 = reinterpret_cast< wxWindow * >(argp1);
30375 {
30376 PyThreadState* __tstate = wxPyBeginAllowThreads();
30377 (arg1)->Raise();
30378 wxPyEndAllowThreads(__tstate);
30379 if (PyErr_Occurred()) SWIG_fail;
30380 }
30381 resultobj = SWIG_Py_Void();
30382 return resultobj;
30383 fail:
30384 return NULL;
30385 }
30386
30387
30388 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30389 PyObject *resultobj = 0;
30390 wxWindow *arg1 = (wxWindow *) 0 ;
30391 void *argp1 = 0 ;
30392 int res1 = 0 ;
30393 PyObject *swig_obj[1] ;
30394
30395 if (!args) SWIG_fail;
30396 swig_obj[0] = args;
30397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30398 if (!SWIG_IsOK(res1)) {
30399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30400 }
30401 arg1 = reinterpret_cast< wxWindow * >(argp1);
30402 {
30403 PyThreadState* __tstate = wxPyBeginAllowThreads();
30404 (arg1)->Lower();
30405 wxPyEndAllowThreads(__tstate);
30406 if (PyErr_Occurred()) SWIG_fail;
30407 }
30408 resultobj = SWIG_Py_Void();
30409 return resultobj;
30410 fail:
30411 return NULL;
30412 }
30413
30414
30415 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30416 PyObject *resultobj = 0;
30417 wxWindow *arg1 = (wxWindow *) 0 ;
30418 wxSize *arg2 = 0 ;
30419 void *argp1 = 0 ;
30420 int res1 = 0 ;
30421 wxSize temp2 ;
30422 PyObject * obj0 = 0 ;
30423 PyObject * obj1 = 0 ;
30424 char * kwnames[] = {
30425 (char *) "self",(char *) "size", NULL
30426 };
30427
30428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30430 if (!SWIG_IsOK(res1)) {
30431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30432 }
30433 arg1 = reinterpret_cast< wxWindow * >(argp1);
30434 {
30435 arg2 = &temp2;
30436 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30437 }
30438 {
30439 PyThreadState* __tstate = wxPyBeginAllowThreads();
30440 (arg1)->SetClientSize((wxSize const &)*arg2);
30441 wxPyEndAllowThreads(__tstate);
30442 if (PyErr_Occurred()) SWIG_fail;
30443 }
30444 resultobj = SWIG_Py_Void();
30445 return resultobj;
30446 fail:
30447 return NULL;
30448 }
30449
30450
30451 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30452 PyObject *resultobj = 0;
30453 wxWindow *arg1 = (wxWindow *) 0 ;
30454 int arg2 ;
30455 int arg3 ;
30456 void *argp1 = 0 ;
30457 int res1 = 0 ;
30458 int val2 ;
30459 int ecode2 = 0 ;
30460 int val3 ;
30461 int ecode3 = 0 ;
30462 PyObject * obj0 = 0 ;
30463 PyObject * obj1 = 0 ;
30464 PyObject * obj2 = 0 ;
30465 char * kwnames[] = {
30466 (char *) "self",(char *) "width",(char *) "height", NULL
30467 };
30468
30469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30471 if (!SWIG_IsOK(res1)) {
30472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30473 }
30474 arg1 = reinterpret_cast< wxWindow * >(argp1);
30475 ecode2 = SWIG_AsVal_int(obj1, &val2);
30476 if (!SWIG_IsOK(ecode2)) {
30477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30478 }
30479 arg2 = static_cast< int >(val2);
30480 ecode3 = SWIG_AsVal_int(obj2, &val3);
30481 if (!SWIG_IsOK(ecode3)) {
30482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30483 }
30484 arg3 = static_cast< int >(val3);
30485 {
30486 PyThreadState* __tstate = wxPyBeginAllowThreads();
30487 (arg1)->SetClientSize(arg2,arg3);
30488 wxPyEndAllowThreads(__tstate);
30489 if (PyErr_Occurred()) SWIG_fail;
30490 }
30491 resultobj = SWIG_Py_Void();
30492 return resultobj;
30493 fail:
30494 return NULL;
30495 }
30496
30497
30498 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30499 PyObject *resultobj = 0;
30500 wxWindow *arg1 = (wxWindow *) 0 ;
30501 wxRect *arg2 = 0 ;
30502 void *argp1 = 0 ;
30503 int res1 = 0 ;
30504 wxRect temp2 ;
30505 PyObject * obj0 = 0 ;
30506 PyObject * obj1 = 0 ;
30507 char * kwnames[] = {
30508 (char *) "self",(char *) "rect", NULL
30509 };
30510
30511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30513 if (!SWIG_IsOK(res1)) {
30514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30515 }
30516 arg1 = reinterpret_cast< wxWindow * >(argp1);
30517 {
30518 arg2 = &temp2;
30519 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30520 }
30521 {
30522 PyThreadState* __tstate = wxPyBeginAllowThreads();
30523 (arg1)->SetClientSize((wxRect const &)*arg2);
30524 wxPyEndAllowThreads(__tstate);
30525 if (PyErr_Occurred()) SWIG_fail;
30526 }
30527 resultobj = SWIG_Py_Void();
30528 return resultobj;
30529 fail:
30530 return NULL;
30531 }
30532
30533
30534 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30535 PyObject *resultobj = 0;
30536 wxWindow *arg1 = (wxWindow *) 0 ;
30537 wxPoint result;
30538 void *argp1 = 0 ;
30539 int res1 = 0 ;
30540 PyObject *swig_obj[1] ;
30541
30542 if (!args) SWIG_fail;
30543 swig_obj[0] = args;
30544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30545 if (!SWIG_IsOK(res1)) {
30546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30547 }
30548 arg1 = reinterpret_cast< wxWindow * >(argp1);
30549 {
30550 PyThreadState* __tstate = wxPyBeginAllowThreads();
30551 result = ((wxWindow const *)arg1)->GetPosition();
30552 wxPyEndAllowThreads(__tstate);
30553 if (PyErr_Occurred()) SWIG_fail;
30554 }
30555 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30556 return resultobj;
30557 fail:
30558 return NULL;
30559 }
30560
30561
30562 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30563 PyObject *resultobj = 0;
30564 wxWindow *arg1 = (wxWindow *) 0 ;
30565 int *arg2 = (int *) 0 ;
30566 int *arg3 = (int *) 0 ;
30567 void *argp1 = 0 ;
30568 int res1 = 0 ;
30569 int temp2 ;
30570 int res2 = SWIG_TMPOBJ ;
30571 int temp3 ;
30572 int res3 = SWIG_TMPOBJ ;
30573 PyObject *swig_obj[1] ;
30574
30575 arg2 = &temp2;
30576 arg3 = &temp3;
30577 if (!args) SWIG_fail;
30578 swig_obj[0] = args;
30579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30580 if (!SWIG_IsOK(res1)) {
30581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30582 }
30583 arg1 = reinterpret_cast< wxWindow * >(argp1);
30584 {
30585 PyThreadState* __tstate = wxPyBeginAllowThreads();
30586 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30587 wxPyEndAllowThreads(__tstate);
30588 if (PyErr_Occurred()) SWIG_fail;
30589 }
30590 resultobj = SWIG_Py_Void();
30591 if (SWIG_IsTmpObj(res2)) {
30592 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30593 } else {
30594 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30595 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30596 }
30597 if (SWIG_IsTmpObj(res3)) {
30598 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30599 } else {
30600 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30601 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30602 }
30603 return resultobj;
30604 fail:
30605 return NULL;
30606 }
30607
30608
30609 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30610 PyObject *resultobj = 0;
30611 wxWindow *arg1 = (wxWindow *) 0 ;
30612 wxPoint result;
30613 void *argp1 = 0 ;
30614 int res1 = 0 ;
30615 PyObject *swig_obj[1] ;
30616
30617 if (!args) SWIG_fail;
30618 swig_obj[0] = args;
30619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30620 if (!SWIG_IsOK(res1)) {
30621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30622 }
30623 arg1 = reinterpret_cast< wxWindow * >(argp1);
30624 {
30625 PyThreadState* __tstate = wxPyBeginAllowThreads();
30626 result = ((wxWindow const *)arg1)->GetScreenPosition();
30627 wxPyEndAllowThreads(__tstate);
30628 if (PyErr_Occurred()) SWIG_fail;
30629 }
30630 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30631 return resultobj;
30632 fail:
30633 return NULL;
30634 }
30635
30636
30637 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30638 PyObject *resultobj = 0;
30639 wxWindow *arg1 = (wxWindow *) 0 ;
30640 int *arg2 = (int *) 0 ;
30641 int *arg3 = (int *) 0 ;
30642 void *argp1 = 0 ;
30643 int res1 = 0 ;
30644 int temp2 ;
30645 int res2 = SWIG_TMPOBJ ;
30646 int temp3 ;
30647 int res3 = SWIG_TMPOBJ ;
30648 PyObject *swig_obj[1] ;
30649
30650 arg2 = &temp2;
30651 arg3 = &temp3;
30652 if (!args) SWIG_fail;
30653 swig_obj[0] = args;
30654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30655 if (!SWIG_IsOK(res1)) {
30656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30657 }
30658 arg1 = reinterpret_cast< wxWindow * >(argp1);
30659 {
30660 PyThreadState* __tstate = wxPyBeginAllowThreads();
30661 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30662 wxPyEndAllowThreads(__tstate);
30663 if (PyErr_Occurred()) SWIG_fail;
30664 }
30665 resultobj = SWIG_Py_Void();
30666 if (SWIG_IsTmpObj(res2)) {
30667 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30668 } else {
30669 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30670 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30671 }
30672 if (SWIG_IsTmpObj(res3)) {
30673 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30674 } else {
30675 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30676 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30677 }
30678 return resultobj;
30679 fail:
30680 return NULL;
30681 }
30682
30683
30684 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30685 PyObject *resultobj = 0;
30686 wxWindow *arg1 = (wxWindow *) 0 ;
30687 wxRect result;
30688 void *argp1 = 0 ;
30689 int res1 = 0 ;
30690 PyObject *swig_obj[1] ;
30691
30692 if (!args) SWIG_fail;
30693 swig_obj[0] = args;
30694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30695 if (!SWIG_IsOK(res1)) {
30696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30697 }
30698 arg1 = reinterpret_cast< wxWindow * >(argp1);
30699 {
30700 PyThreadState* __tstate = wxPyBeginAllowThreads();
30701 result = ((wxWindow const *)arg1)->GetScreenRect();
30702 wxPyEndAllowThreads(__tstate);
30703 if (PyErr_Occurred()) SWIG_fail;
30704 }
30705 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30706 return resultobj;
30707 fail:
30708 return NULL;
30709 }
30710
30711
30712 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30713 PyObject *resultobj = 0;
30714 wxWindow *arg1 = (wxWindow *) 0 ;
30715 wxSize result;
30716 void *argp1 = 0 ;
30717 int res1 = 0 ;
30718 PyObject *swig_obj[1] ;
30719
30720 if (!args) SWIG_fail;
30721 swig_obj[0] = args;
30722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30723 if (!SWIG_IsOK(res1)) {
30724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30725 }
30726 arg1 = reinterpret_cast< wxWindow * >(argp1);
30727 {
30728 PyThreadState* __tstate = wxPyBeginAllowThreads();
30729 result = ((wxWindow const *)arg1)->GetSize();
30730 wxPyEndAllowThreads(__tstate);
30731 if (PyErr_Occurred()) SWIG_fail;
30732 }
30733 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30734 return resultobj;
30735 fail:
30736 return NULL;
30737 }
30738
30739
30740 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30741 PyObject *resultobj = 0;
30742 wxWindow *arg1 = (wxWindow *) 0 ;
30743 int *arg2 = (int *) 0 ;
30744 int *arg3 = (int *) 0 ;
30745 void *argp1 = 0 ;
30746 int res1 = 0 ;
30747 int temp2 ;
30748 int res2 = SWIG_TMPOBJ ;
30749 int temp3 ;
30750 int res3 = SWIG_TMPOBJ ;
30751 PyObject *swig_obj[1] ;
30752
30753 arg2 = &temp2;
30754 arg3 = &temp3;
30755 if (!args) SWIG_fail;
30756 swig_obj[0] = args;
30757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30758 if (!SWIG_IsOK(res1)) {
30759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30760 }
30761 arg1 = reinterpret_cast< wxWindow * >(argp1);
30762 {
30763 PyThreadState* __tstate = wxPyBeginAllowThreads();
30764 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30765 wxPyEndAllowThreads(__tstate);
30766 if (PyErr_Occurred()) SWIG_fail;
30767 }
30768 resultobj = SWIG_Py_Void();
30769 if (SWIG_IsTmpObj(res2)) {
30770 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30771 } else {
30772 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30773 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30774 }
30775 if (SWIG_IsTmpObj(res3)) {
30776 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30777 } else {
30778 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30779 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30780 }
30781 return resultobj;
30782 fail:
30783 return NULL;
30784 }
30785
30786
30787 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30788 PyObject *resultobj = 0;
30789 wxWindow *arg1 = (wxWindow *) 0 ;
30790 wxRect result;
30791 void *argp1 = 0 ;
30792 int res1 = 0 ;
30793 PyObject *swig_obj[1] ;
30794
30795 if (!args) SWIG_fail;
30796 swig_obj[0] = args;
30797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30798 if (!SWIG_IsOK(res1)) {
30799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30800 }
30801 arg1 = reinterpret_cast< wxWindow * >(argp1);
30802 {
30803 PyThreadState* __tstate = wxPyBeginAllowThreads();
30804 result = ((wxWindow const *)arg1)->GetRect();
30805 wxPyEndAllowThreads(__tstate);
30806 if (PyErr_Occurred()) SWIG_fail;
30807 }
30808 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30809 return resultobj;
30810 fail:
30811 return NULL;
30812 }
30813
30814
30815 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30816 PyObject *resultobj = 0;
30817 wxWindow *arg1 = (wxWindow *) 0 ;
30818 wxSize result;
30819 void *argp1 = 0 ;
30820 int res1 = 0 ;
30821 PyObject *swig_obj[1] ;
30822
30823 if (!args) SWIG_fail;
30824 swig_obj[0] = args;
30825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30826 if (!SWIG_IsOK(res1)) {
30827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30828 }
30829 arg1 = reinterpret_cast< wxWindow * >(argp1);
30830 {
30831 PyThreadState* __tstate = wxPyBeginAllowThreads();
30832 result = ((wxWindow const *)arg1)->GetClientSize();
30833 wxPyEndAllowThreads(__tstate);
30834 if (PyErr_Occurred()) SWIG_fail;
30835 }
30836 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30837 return resultobj;
30838 fail:
30839 return NULL;
30840 }
30841
30842
30843 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30844 PyObject *resultobj = 0;
30845 wxWindow *arg1 = (wxWindow *) 0 ;
30846 int *arg2 = (int *) 0 ;
30847 int *arg3 = (int *) 0 ;
30848 void *argp1 = 0 ;
30849 int res1 = 0 ;
30850 int temp2 ;
30851 int res2 = SWIG_TMPOBJ ;
30852 int temp3 ;
30853 int res3 = SWIG_TMPOBJ ;
30854 PyObject *swig_obj[1] ;
30855
30856 arg2 = &temp2;
30857 arg3 = &temp3;
30858 if (!args) SWIG_fail;
30859 swig_obj[0] = args;
30860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30861 if (!SWIG_IsOK(res1)) {
30862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30863 }
30864 arg1 = reinterpret_cast< wxWindow * >(argp1);
30865 {
30866 PyThreadState* __tstate = wxPyBeginAllowThreads();
30867 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30868 wxPyEndAllowThreads(__tstate);
30869 if (PyErr_Occurred()) SWIG_fail;
30870 }
30871 resultobj = SWIG_Py_Void();
30872 if (SWIG_IsTmpObj(res2)) {
30873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30874 } else {
30875 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30877 }
30878 if (SWIG_IsTmpObj(res3)) {
30879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30880 } else {
30881 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30882 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30883 }
30884 return resultobj;
30885 fail:
30886 return NULL;
30887 }
30888
30889
30890 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30891 PyObject *resultobj = 0;
30892 wxWindow *arg1 = (wxWindow *) 0 ;
30893 wxPoint result;
30894 void *argp1 = 0 ;
30895 int res1 = 0 ;
30896 PyObject *swig_obj[1] ;
30897
30898 if (!args) SWIG_fail;
30899 swig_obj[0] = args;
30900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30901 if (!SWIG_IsOK(res1)) {
30902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30903 }
30904 arg1 = reinterpret_cast< wxWindow * >(argp1);
30905 {
30906 PyThreadState* __tstate = wxPyBeginAllowThreads();
30907 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30908 wxPyEndAllowThreads(__tstate);
30909 if (PyErr_Occurred()) SWIG_fail;
30910 }
30911 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30912 return resultobj;
30913 fail:
30914 return NULL;
30915 }
30916
30917
30918 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30919 PyObject *resultobj = 0;
30920 wxWindow *arg1 = (wxWindow *) 0 ;
30921 wxRect result;
30922 void *argp1 = 0 ;
30923 int res1 = 0 ;
30924 PyObject *swig_obj[1] ;
30925
30926 if (!args) SWIG_fail;
30927 swig_obj[0] = args;
30928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30929 if (!SWIG_IsOK(res1)) {
30930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30931 }
30932 arg1 = reinterpret_cast< wxWindow * >(argp1);
30933 {
30934 PyThreadState* __tstate = wxPyBeginAllowThreads();
30935 result = ((wxWindow const *)arg1)->GetClientRect();
30936 wxPyEndAllowThreads(__tstate);
30937 if (PyErr_Occurred()) SWIG_fail;
30938 }
30939 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30940 return resultobj;
30941 fail:
30942 return NULL;
30943 }
30944
30945
30946 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30947 PyObject *resultobj = 0;
30948 wxWindow *arg1 = (wxWindow *) 0 ;
30949 wxSize result;
30950 void *argp1 = 0 ;
30951 int res1 = 0 ;
30952 PyObject *swig_obj[1] ;
30953
30954 if (!args) SWIG_fail;
30955 swig_obj[0] = args;
30956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30957 if (!SWIG_IsOK(res1)) {
30958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30959 }
30960 arg1 = reinterpret_cast< wxWindow * >(argp1);
30961 {
30962 PyThreadState* __tstate = wxPyBeginAllowThreads();
30963 result = ((wxWindow const *)arg1)->GetBestSize();
30964 wxPyEndAllowThreads(__tstate);
30965 if (PyErr_Occurred()) SWIG_fail;
30966 }
30967 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30968 return resultobj;
30969 fail:
30970 return NULL;
30971 }
30972
30973
30974 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30975 PyObject *resultobj = 0;
30976 wxWindow *arg1 = (wxWindow *) 0 ;
30977 int *arg2 = (int *) 0 ;
30978 int *arg3 = (int *) 0 ;
30979 void *argp1 = 0 ;
30980 int res1 = 0 ;
30981 int temp2 ;
30982 int res2 = SWIG_TMPOBJ ;
30983 int temp3 ;
30984 int res3 = SWIG_TMPOBJ ;
30985 PyObject *swig_obj[1] ;
30986
30987 arg2 = &temp2;
30988 arg3 = &temp3;
30989 if (!args) SWIG_fail;
30990 swig_obj[0] = args;
30991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30992 if (!SWIG_IsOK(res1)) {
30993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30994 }
30995 arg1 = reinterpret_cast< wxWindow * >(argp1);
30996 {
30997 PyThreadState* __tstate = wxPyBeginAllowThreads();
30998 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
30999 wxPyEndAllowThreads(__tstate);
31000 if (PyErr_Occurred()) SWIG_fail;
31001 }
31002 resultobj = SWIG_Py_Void();
31003 if (SWIG_IsTmpObj(res2)) {
31004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31005 } else {
31006 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31008 }
31009 if (SWIG_IsTmpObj(res3)) {
31010 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31011 } else {
31012 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31013 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31014 }
31015 return resultobj;
31016 fail:
31017 return NULL;
31018 }
31019
31020
31021 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31022 PyObject *resultobj = 0;
31023 wxWindow *arg1 = (wxWindow *) 0 ;
31024 void *argp1 = 0 ;
31025 int res1 = 0 ;
31026 PyObject *swig_obj[1] ;
31027
31028 if (!args) SWIG_fail;
31029 swig_obj[0] = args;
31030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31031 if (!SWIG_IsOK(res1)) {
31032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31033 }
31034 arg1 = reinterpret_cast< wxWindow * >(argp1);
31035 {
31036 PyThreadState* __tstate = wxPyBeginAllowThreads();
31037 (arg1)->InvalidateBestSize();
31038 wxPyEndAllowThreads(__tstate);
31039 if (PyErr_Occurred()) SWIG_fail;
31040 }
31041 resultobj = SWIG_Py_Void();
31042 return resultobj;
31043 fail:
31044 return NULL;
31045 }
31046
31047
31048 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31049 PyObject *resultobj = 0;
31050 wxWindow *arg1 = (wxWindow *) 0 ;
31051 wxSize *arg2 = 0 ;
31052 void *argp1 = 0 ;
31053 int res1 = 0 ;
31054 wxSize temp2 ;
31055 PyObject * obj0 = 0 ;
31056 PyObject * obj1 = 0 ;
31057 char * kwnames[] = {
31058 (char *) "self",(char *) "size", NULL
31059 };
31060
31061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31063 if (!SWIG_IsOK(res1)) {
31064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31065 }
31066 arg1 = reinterpret_cast< wxWindow * >(argp1);
31067 {
31068 arg2 = &temp2;
31069 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31070 }
31071 {
31072 PyThreadState* __tstate = wxPyBeginAllowThreads();
31073 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31074 wxPyEndAllowThreads(__tstate);
31075 if (PyErr_Occurred()) SWIG_fail;
31076 }
31077 resultobj = SWIG_Py_Void();
31078 return resultobj;
31079 fail:
31080 return NULL;
31081 }
31082
31083
31084 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31085 PyObject *resultobj = 0;
31086 wxWindow *arg1 = (wxWindow *) 0 ;
31087 wxSize result;
31088 void *argp1 = 0 ;
31089 int res1 = 0 ;
31090 PyObject *swig_obj[1] ;
31091
31092 if (!args) SWIG_fail;
31093 swig_obj[0] = args;
31094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31095 if (!SWIG_IsOK(res1)) {
31096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31097 }
31098 arg1 = reinterpret_cast< wxWindow * >(argp1);
31099 {
31100 PyThreadState* __tstate = wxPyBeginAllowThreads();
31101 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31102 wxPyEndAllowThreads(__tstate);
31103 if (PyErr_Occurred()) SWIG_fail;
31104 }
31105 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31106 return resultobj;
31107 fail:
31108 return NULL;
31109 }
31110
31111
31112 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31113 PyObject *resultobj = 0;
31114 wxWindow *arg1 = (wxWindow *) 0 ;
31115 wxSize result;
31116 void *argp1 = 0 ;
31117 int res1 = 0 ;
31118 PyObject *swig_obj[1] ;
31119
31120 if (!args) SWIG_fail;
31121 swig_obj[0] = args;
31122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31123 if (!SWIG_IsOK(res1)) {
31124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31125 }
31126 arg1 = reinterpret_cast< wxWindow * >(argp1);
31127 {
31128 PyThreadState* __tstate = wxPyBeginAllowThreads();
31129 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31141 PyObject *resultobj = 0;
31142 wxWindow *arg1 = (wxWindow *) 0 ;
31143 int arg2 = (int) wxBOTH ;
31144 void *argp1 = 0 ;
31145 int res1 = 0 ;
31146 int val2 ;
31147 int ecode2 = 0 ;
31148 PyObject * obj0 = 0 ;
31149 PyObject * obj1 = 0 ;
31150 char * kwnames[] = {
31151 (char *) "self",(char *) "direction", NULL
31152 };
31153
31154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31156 if (!SWIG_IsOK(res1)) {
31157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31158 }
31159 arg1 = reinterpret_cast< wxWindow * >(argp1);
31160 if (obj1) {
31161 ecode2 = SWIG_AsVal_int(obj1, &val2);
31162 if (!SWIG_IsOK(ecode2)) {
31163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31164 }
31165 arg2 = static_cast< int >(val2);
31166 }
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 (arg1)->Center(arg2);
31170 wxPyEndAllowThreads(__tstate);
31171 if (PyErr_Occurred()) SWIG_fail;
31172 }
31173 resultobj = SWIG_Py_Void();
31174 return resultobj;
31175 fail:
31176 return NULL;
31177 }
31178
31179
31180 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31181 PyObject *resultobj = 0;
31182 wxWindow *arg1 = (wxWindow *) 0 ;
31183 int arg2 = (int) wxBOTH ;
31184 void *argp1 = 0 ;
31185 int res1 = 0 ;
31186 int val2 ;
31187 int ecode2 = 0 ;
31188 PyObject * obj0 = 0 ;
31189 PyObject * obj1 = 0 ;
31190 char * kwnames[] = {
31191 (char *) "self",(char *) "dir", NULL
31192 };
31193
31194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31196 if (!SWIG_IsOK(res1)) {
31197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31198 }
31199 arg1 = reinterpret_cast< wxWindow * >(argp1);
31200 if (obj1) {
31201 ecode2 = SWIG_AsVal_int(obj1, &val2);
31202 if (!SWIG_IsOK(ecode2)) {
31203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31204 }
31205 arg2 = static_cast< int >(val2);
31206 }
31207 {
31208 PyThreadState* __tstate = wxPyBeginAllowThreads();
31209 (arg1)->CenterOnParent(arg2);
31210 wxPyEndAllowThreads(__tstate);
31211 if (PyErr_Occurred()) SWIG_fail;
31212 }
31213 resultobj = SWIG_Py_Void();
31214 return resultobj;
31215 fail:
31216 return NULL;
31217 }
31218
31219
31220 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31221 PyObject *resultobj = 0;
31222 wxWindow *arg1 = (wxWindow *) 0 ;
31223 void *argp1 = 0 ;
31224 int res1 = 0 ;
31225 PyObject *swig_obj[1] ;
31226
31227 if (!args) SWIG_fail;
31228 swig_obj[0] = args;
31229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31230 if (!SWIG_IsOK(res1)) {
31231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31232 }
31233 arg1 = reinterpret_cast< wxWindow * >(argp1);
31234 {
31235 PyThreadState* __tstate = wxPyBeginAllowThreads();
31236 (arg1)->Fit();
31237 wxPyEndAllowThreads(__tstate);
31238 if (PyErr_Occurred()) SWIG_fail;
31239 }
31240 resultobj = SWIG_Py_Void();
31241 return resultobj;
31242 fail:
31243 return NULL;
31244 }
31245
31246
31247 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31248 PyObject *resultobj = 0;
31249 wxWindow *arg1 = (wxWindow *) 0 ;
31250 void *argp1 = 0 ;
31251 int res1 = 0 ;
31252 PyObject *swig_obj[1] ;
31253
31254 if (!args) SWIG_fail;
31255 swig_obj[0] = args;
31256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31257 if (!SWIG_IsOK(res1)) {
31258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31259 }
31260 arg1 = reinterpret_cast< wxWindow * >(argp1);
31261 {
31262 PyThreadState* __tstate = wxPyBeginAllowThreads();
31263 (arg1)->FitInside();
31264 wxPyEndAllowThreads(__tstate);
31265 if (PyErr_Occurred()) SWIG_fail;
31266 }
31267 resultobj = SWIG_Py_Void();
31268 return resultobj;
31269 fail:
31270 return NULL;
31271 }
31272
31273
31274 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31275 PyObject *resultobj = 0;
31276 wxWindow *arg1 = (wxWindow *) 0 ;
31277 int arg2 ;
31278 int arg3 ;
31279 int arg4 = (int) -1 ;
31280 int arg5 = (int) -1 ;
31281 int arg6 = (int) -1 ;
31282 int arg7 = (int) -1 ;
31283 void *argp1 = 0 ;
31284 int res1 = 0 ;
31285 int val2 ;
31286 int ecode2 = 0 ;
31287 int val3 ;
31288 int ecode3 = 0 ;
31289 int val4 ;
31290 int ecode4 = 0 ;
31291 int val5 ;
31292 int ecode5 = 0 ;
31293 int val6 ;
31294 int ecode6 = 0 ;
31295 int val7 ;
31296 int ecode7 = 0 ;
31297 PyObject * obj0 = 0 ;
31298 PyObject * obj1 = 0 ;
31299 PyObject * obj2 = 0 ;
31300 PyObject * obj3 = 0 ;
31301 PyObject * obj4 = 0 ;
31302 PyObject * obj5 = 0 ;
31303 PyObject * obj6 = 0 ;
31304 char * kwnames[] = {
31305 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31306 };
31307
31308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31310 if (!SWIG_IsOK(res1)) {
31311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31312 }
31313 arg1 = reinterpret_cast< wxWindow * >(argp1);
31314 ecode2 = SWIG_AsVal_int(obj1, &val2);
31315 if (!SWIG_IsOK(ecode2)) {
31316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31317 }
31318 arg2 = static_cast< int >(val2);
31319 ecode3 = SWIG_AsVal_int(obj2, &val3);
31320 if (!SWIG_IsOK(ecode3)) {
31321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31322 }
31323 arg3 = static_cast< int >(val3);
31324 if (obj3) {
31325 ecode4 = SWIG_AsVal_int(obj3, &val4);
31326 if (!SWIG_IsOK(ecode4)) {
31327 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31328 }
31329 arg4 = static_cast< int >(val4);
31330 }
31331 if (obj4) {
31332 ecode5 = SWIG_AsVal_int(obj4, &val5);
31333 if (!SWIG_IsOK(ecode5)) {
31334 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31335 }
31336 arg5 = static_cast< int >(val5);
31337 }
31338 if (obj5) {
31339 ecode6 = SWIG_AsVal_int(obj5, &val6);
31340 if (!SWIG_IsOK(ecode6)) {
31341 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31342 }
31343 arg6 = static_cast< int >(val6);
31344 }
31345 if (obj6) {
31346 ecode7 = SWIG_AsVal_int(obj6, &val7);
31347 if (!SWIG_IsOK(ecode7)) {
31348 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31349 }
31350 arg7 = static_cast< int >(val7);
31351 }
31352 {
31353 PyThreadState* __tstate = wxPyBeginAllowThreads();
31354 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31355 wxPyEndAllowThreads(__tstate);
31356 if (PyErr_Occurred()) SWIG_fail;
31357 }
31358 resultobj = SWIG_Py_Void();
31359 return resultobj;
31360 fail:
31361 return NULL;
31362 }
31363
31364
31365 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31366 PyObject *resultobj = 0;
31367 wxWindow *arg1 = (wxWindow *) 0 ;
31368 wxSize *arg2 = 0 ;
31369 wxSize const &arg3_defvalue = wxDefaultSize ;
31370 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31371 wxSize const &arg4_defvalue = wxDefaultSize ;
31372 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31373 void *argp1 = 0 ;
31374 int res1 = 0 ;
31375 wxSize temp2 ;
31376 wxSize temp3 ;
31377 wxSize temp4 ;
31378 PyObject * obj0 = 0 ;
31379 PyObject * obj1 = 0 ;
31380 PyObject * obj2 = 0 ;
31381 PyObject * obj3 = 0 ;
31382 char * kwnames[] = {
31383 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31384 };
31385
31386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31388 if (!SWIG_IsOK(res1)) {
31389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31390 }
31391 arg1 = reinterpret_cast< wxWindow * >(argp1);
31392 {
31393 arg2 = &temp2;
31394 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31395 }
31396 if (obj2) {
31397 {
31398 arg3 = &temp3;
31399 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31400 }
31401 }
31402 if (obj3) {
31403 {
31404 arg4 = &temp4;
31405 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31406 }
31407 }
31408 {
31409 PyThreadState* __tstate = wxPyBeginAllowThreads();
31410 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31411 wxPyEndAllowThreads(__tstate);
31412 if (PyErr_Occurred()) SWIG_fail;
31413 }
31414 resultobj = SWIG_Py_Void();
31415 return resultobj;
31416 fail:
31417 return NULL;
31418 }
31419
31420
31421 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31422 PyObject *resultobj = 0;
31423 wxWindow *arg1 = (wxWindow *) 0 ;
31424 int arg2 ;
31425 int arg3 ;
31426 int arg4 = (int) -1 ;
31427 int arg5 = (int) -1 ;
31428 void *argp1 = 0 ;
31429 int res1 = 0 ;
31430 int val2 ;
31431 int ecode2 = 0 ;
31432 int val3 ;
31433 int ecode3 = 0 ;
31434 int val4 ;
31435 int ecode4 = 0 ;
31436 int val5 ;
31437 int ecode5 = 0 ;
31438 PyObject * obj0 = 0 ;
31439 PyObject * obj1 = 0 ;
31440 PyObject * obj2 = 0 ;
31441 PyObject * obj3 = 0 ;
31442 PyObject * obj4 = 0 ;
31443 char * kwnames[] = {
31444 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31445 };
31446
31447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31449 if (!SWIG_IsOK(res1)) {
31450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31451 }
31452 arg1 = reinterpret_cast< wxWindow * >(argp1);
31453 ecode2 = SWIG_AsVal_int(obj1, &val2);
31454 if (!SWIG_IsOK(ecode2)) {
31455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31456 }
31457 arg2 = static_cast< int >(val2);
31458 ecode3 = SWIG_AsVal_int(obj2, &val3);
31459 if (!SWIG_IsOK(ecode3)) {
31460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31461 }
31462 arg3 = static_cast< int >(val3);
31463 if (obj3) {
31464 ecode4 = SWIG_AsVal_int(obj3, &val4);
31465 if (!SWIG_IsOK(ecode4)) {
31466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31467 }
31468 arg4 = static_cast< int >(val4);
31469 }
31470 if (obj4) {
31471 ecode5 = SWIG_AsVal_int(obj4, &val5);
31472 if (!SWIG_IsOK(ecode5)) {
31473 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31474 }
31475 arg5 = static_cast< int >(val5);
31476 }
31477 {
31478 PyThreadState* __tstate = wxPyBeginAllowThreads();
31479 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31480 wxPyEndAllowThreads(__tstate);
31481 if (PyErr_Occurred()) SWIG_fail;
31482 }
31483 resultobj = SWIG_Py_Void();
31484 return resultobj;
31485 fail:
31486 return NULL;
31487 }
31488
31489
31490 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31491 PyObject *resultobj = 0;
31492 wxWindow *arg1 = (wxWindow *) 0 ;
31493 wxSize *arg2 = 0 ;
31494 wxSize const &arg3_defvalue = wxDefaultSize ;
31495 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31496 void *argp1 = 0 ;
31497 int res1 = 0 ;
31498 wxSize temp2 ;
31499 wxSize temp3 ;
31500 PyObject * obj0 = 0 ;
31501 PyObject * obj1 = 0 ;
31502 PyObject * obj2 = 0 ;
31503 char * kwnames[] = {
31504 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31505 };
31506
31507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31509 if (!SWIG_IsOK(res1)) {
31510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31511 }
31512 arg1 = reinterpret_cast< wxWindow * >(argp1);
31513 {
31514 arg2 = &temp2;
31515 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31516 }
31517 if (obj2) {
31518 {
31519 arg3 = &temp3;
31520 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31521 }
31522 }
31523 {
31524 PyThreadState* __tstate = wxPyBeginAllowThreads();
31525 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31526 wxPyEndAllowThreads(__tstate);
31527 if (PyErr_Occurred()) SWIG_fail;
31528 }
31529 resultobj = SWIG_Py_Void();
31530 return resultobj;
31531 fail:
31532 return NULL;
31533 }
31534
31535
31536 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31537 PyObject *resultobj = 0;
31538 wxWindow *arg1 = (wxWindow *) 0 ;
31539 wxSize result;
31540 void *argp1 = 0 ;
31541 int res1 = 0 ;
31542 PyObject *swig_obj[1] ;
31543
31544 if (!args) SWIG_fail;
31545 swig_obj[0] = args;
31546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31547 if (!SWIG_IsOK(res1)) {
31548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31549 }
31550 arg1 = reinterpret_cast< wxWindow * >(argp1);
31551 {
31552 PyThreadState* __tstate = wxPyBeginAllowThreads();
31553 result = ((wxWindow const *)arg1)->GetMaxSize();
31554 wxPyEndAllowThreads(__tstate);
31555 if (PyErr_Occurred()) SWIG_fail;
31556 }
31557 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31558 return resultobj;
31559 fail:
31560 return NULL;
31561 }
31562
31563
31564 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31565 PyObject *resultobj = 0;
31566 wxWindow *arg1 = (wxWindow *) 0 ;
31567 wxSize result;
31568 void *argp1 = 0 ;
31569 int res1 = 0 ;
31570 PyObject *swig_obj[1] ;
31571
31572 if (!args) SWIG_fail;
31573 swig_obj[0] = args;
31574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31575 if (!SWIG_IsOK(res1)) {
31576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31577 }
31578 arg1 = reinterpret_cast< wxWindow * >(argp1);
31579 {
31580 PyThreadState* __tstate = wxPyBeginAllowThreads();
31581 result = ((wxWindow const *)arg1)->GetMinSize();
31582 wxPyEndAllowThreads(__tstate);
31583 if (PyErr_Occurred()) SWIG_fail;
31584 }
31585 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31586 return resultobj;
31587 fail:
31588 return NULL;
31589 }
31590
31591
31592 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31593 PyObject *resultobj = 0;
31594 wxWindow *arg1 = (wxWindow *) 0 ;
31595 wxSize *arg2 = 0 ;
31596 void *argp1 = 0 ;
31597 int res1 = 0 ;
31598 wxSize temp2 ;
31599 PyObject * obj0 = 0 ;
31600 PyObject * obj1 = 0 ;
31601 char * kwnames[] = {
31602 (char *) "self",(char *) "minSize", NULL
31603 };
31604
31605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31607 if (!SWIG_IsOK(res1)) {
31608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31609 }
31610 arg1 = reinterpret_cast< wxWindow * >(argp1);
31611 {
31612 arg2 = &temp2;
31613 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31614 }
31615 {
31616 PyThreadState* __tstate = wxPyBeginAllowThreads();
31617 (arg1)->SetMinSize((wxSize const &)*arg2);
31618 wxPyEndAllowThreads(__tstate);
31619 if (PyErr_Occurred()) SWIG_fail;
31620 }
31621 resultobj = SWIG_Py_Void();
31622 return resultobj;
31623 fail:
31624 return NULL;
31625 }
31626
31627
31628 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31629 PyObject *resultobj = 0;
31630 wxWindow *arg1 = (wxWindow *) 0 ;
31631 wxSize *arg2 = 0 ;
31632 void *argp1 = 0 ;
31633 int res1 = 0 ;
31634 wxSize temp2 ;
31635 PyObject * obj0 = 0 ;
31636 PyObject * obj1 = 0 ;
31637 char * kwnames[] = {
31638 (char *) "self",(char *) "maxSize", NULL
31639 };
31640
31641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31643 if (!SWIG_IsOK(res1)) {
31644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31645 }
31646 arg1 = reinterpret_cast< wxWindow * >(argp1);
31647 {
31648 arg2 = &temp2;
31649 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31650 }
31651 {
31652 PyThreadState* __tstate = wxPyBeginAllowThreads();
31653 (arg1)->SetMaxSize((wxSize const &)*arg2);
31654 wxPyEndAllowThreads(__tstate);
31655 if (PyErr_Occurred()) SWIG_fail;
31656 }
31657 resultobj = SWIG_Py_Void();
31658 return resultobj;
31659 fail:
31660 return NULL;
31661 }
31662
31663
31664 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31665 PyObject *resultobj = 0;
31666 wxWindow *arg1 = (wxWindow *) 0 ;
31667 int result;
31668 void *argp1 = 0 ;
31669 int res1 = 0 ;
31670 PyObject *swig_obj[1] ;
31671
31672 if (!args) SWIG_fail;
31673 swig_obj[0] = args;
31674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31675 if (!SWIG_IsOK(res1)) {
31676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31677 }
31678 arg1 = reinterpret_cast< wxWindow * >(argp1);
31679 {
31680 PyThreadState* __tstate = wxPyBeginAllowThreads();
31681 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31682 wxPyEndAllowThreads(__tstate);
31683 if (PyErr_Occurred()) SWIG_fail;
31684 }
31685 resultobj = SWIG_From_int(static_cast< int >(result));
31686 return resultobj;
31687 fail:
31688 return NULL;
31689 }
31690
31691
31692 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31693 PyObject *resultobj = 0;
31694 wxWindow *arg1 = (wxWindow *) 0 ;
31695 int result;
31696 void *argp1 = 0 ;
31697 int res1 = 0 ;
31698 PyObject *swig_obj[1] ;
31699
31700 if (!args) SWIG_fail;
31701 swig_obj[0] = args;
31702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31703 if (!SWIG_IsOK(res1)) {
31704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31705 }
31706 arg1 = reinterpret_cast< wxWindow * >(argp1);
31707 {
31708 PyThreadState* __tstate = wxPyBeginAllowThreads();
31709 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31710 wxPyEndAllowThreads(__tstate);
31711 if (PyErr_Occurred()) SWIG_fail;
31712 }
31713 resultobj = SWIG_From_int(static_cast< int >(result));
31714 return resultobj;
31715 fail:
31716 return NULL;
31717 }
31718
31719
31720 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31721 PyObject *resultobj = 0;
31722 wxWindow *arg1 = (wxWindow *) 0 ;
31723 int result;
31724 void *argp1 = 0 ;
31725 int res1 = 0 ;
31726 PyObject *swig_obj[1] ;
31727
31728 if (!args) SWIG_fail;
31729 swig_obj[0] = args;
31730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31731 if (!SWIG_IsOK(res1)) {
31732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31733 }
31734 arg1 = reinterpret_cast< wxWindow * >(argp1);
31735 {
31736 PyThreadState* __tstate = wxPyBeginAllowThreads();
31737 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31738 wxPyEndAllowThreads(__tstate);
31739 if (PyErr_Occurred()) SWIG_fail;
31740 }
31741 resultobj = SWIG_From_int(static_cast< int >(result));
31742 return resultobj;
31743 fail:
31744 return NULL;
31745 }
31746
31747
31748 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31749 PyObject *resultobj = 0;
31750 wxWindow *arg1 = (wxWindow *) 0 ;
31751 int result;
31752 void *argp1 = 0 ;
31753 int res1 = 0 ;
31754 PyObject *swig_obj[1] ;
31755
31756 if (!args) SWIG_fail;
31757 swig_obj[0] = args;
31758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31759 if (!SWIG_IsOK(res1)) {
31760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31761 }
31762 arg1 = reinterpret_cast< wxWindow * >(argp1);
31763 {
31764 PyThreadState* __tstate = wxPyBeginAllowThreads();
31765 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31766 wxPyEndAllowThreads(__tstate);
31767 if (PyErr_Occurred()) SWIG_fail;
31768 }
31769 resultobj = SWIG_From_int(static_cast< int >(result));
31770 return resultobj;
31771 fail:
31772 return NULL;
31773 }
31774
31775
31776 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31777 PyObject *resultobj = 0;
31778 wxWindow *arg1 = (wxWindow *) 0 ;
31779 wxSize *arg2 = 0 ;
31780 void *argp1 = 0 ;
31781 int res1 = 0 ;
31782 wxSize temp2 ;
31783 PyObject * obj0 = 0 ;
31784 PyObject * obj1 = 0 ;
31785 char * kwnames[] = {
31786 (char *) "self",(char *) "size", NULL
31787 };
31788
31789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31791 if (!SWIG_IsOK(res1)) {
31792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31793 }
31794 arg1 = reinterpret_cast< wxWindow * >(argp1);
31795 {
31796 arg2 = &temp2;
31797 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31798 }
31799 {
31800 PyThreadState* __tstate = wxPyBeginAllowThreads();
31801 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31802 wxPyEndAllowThreads(__tstate);
31803 if (PyErr_Occurred()) SWIG_fail;
31804 }
31805 resultobj = SWIG_Py_Void();
31806 return resultobj;
31807 fail:
31808 return NULL;
31809 }
31810
31811
31812 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31813 PyObject *resultobj = 0;
31814 wxWindow *arg1 = (wxWindow *) 0 ;
31815 int arg2 ;
31816 int arg3 ;
31817 void *argp1 = 0 ;
31818 int res1 = 0 ;
31819 int val2 ;
31820 int ecode2 = 0 ;
31821 int val3 ;
31822 int ecode3 = 0 ;
31823 PyObject * obj0 = 0 ;
31824 PyObject * obj1 = 0 ;
31825 PyObject * obj2 = 0 ;
31826 char * kwnames[] = {
31827 (char *) "self",(char *) "w",(char *) "h", NULL
31828 };
31829
31830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31832 if (!SWIG_IsOK(res1)) {
31833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31834 }
31835 arg1 = reinterpret_cast< wxWindow * >(argp1);
31836 ecode2 = SWIG_AsVal_int(obj1, &val2);
31837 if (!SWIG_IsOK(ecode2)) {
31838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31839 }
31840 arg2 = static_cast< int >(val2);
31841 ecode3 = SWIG_AsVal_int(obj2, &val3);
31842 if (!SWIG_IsOK(ecode3)) {
31843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31844 }
31845 arg3 = static_cast< int >(val3);
31846 {
31847 PyThreadState* __tstate = wxPyBeginAllowThreads();
31848 (arg1)->SetVirtualSize(arg2,arg3);
31849 wxPyEndAllowThreads(__tstate);
31850 if (PyErr_Occurred()) SWIG_fail;
31851 }
31852 resultobj = SWIG_Py_Void();
31853 return resultobj;
31854 fail:
31855 return NULL;
31856 }
31857
31858
31859 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31860 PyObject *resultobj = 0;
31861 wxWindow *arg1 = (wxWindow *) 0 ;
31862 wxSize result;
31863 void *argp1 = 0 ;
31864 int res1 = 0 ;
31865 PyObject *swig_obj[1] ;
31866
31867 if (!args) SWIG_fail;
31868 swig_obj[0] = args;
31869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31870 if (!SWIG_IsOK(res1)) {
31871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31872 }
31873 arg1 = reinterpret_cast< wxWindow * >(argp1);
31874 {
31875 PyThreadState* __tstate = wxPyBeginAllowThreads();
31876 result = ((wxWindow const *)arg1)->GetVirtualSize();
31877 wxPyEndAllowThreads(__tstate);
31878 if (PyErr_Occurred()) SWIG_fail;
31879 }
31880 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31881 return resultobj;
31882 fail:
31883 return NULL;
31884 }
31885
31886
31887 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31888 PyObject *resultobj = 0;
31889 wxWindow *arg1 = (wxWindow *) 0 ;
31890 int *arg2 = (int *) 0 ;
31891 int *arg3 = (int *) 0 ;
31892 void *argp1 = 0 ;
31893 int res1 = 0 ;
31894 int temp2 ;
31895 int res2 = SWIG_TMPOBJ ;
31896 int temp3 ;
31897 int res3 = SWIG_TMPOBJ ;
31898 PyObject *swig_obj[1] ;
31899
31900 arg2 = &temp2;
31901 arg3 = &temp3;
31902 if (!args) SWIG_fail;
31903 swig_obj[0] = args;
31904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31905 if (!SWIG_IsOK(res1)) {
31906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31907 }
31908 arg1 = reinterpret_cast< wxWindow * >(argp1);
31909 {
31910 PyThreadState* __tstate = wxPyBeginAllowThreads();
31911 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31912 wxPyEndAllowThreads(__tstate);
31913 if (PyErr_Occurred()) SWIG_fail;
31914 }
31915 resultobj = SWIG_Py_Void();
31916 if (SWIG_IsTmpObj(res2)) {
31917 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31918 } else {
31919 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31920 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31921 }
31922 if (SWIG_IsTmpObj(res3)) {
31923 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31924 } else {
31925 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31927 }
31928 return resultobj;
31929 fail:
31930 return NULL;
31931 }
31932
31933
31934 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31935 PyObject *resultobj = 0;
31936 wxWindow *arg1 = (wxWindow *) 0 ;
31937 wxSize result;
31938 void *argp1 = 0 ;
31939 int res1 = 0 ;
31940 PyObject *swig_obj[1] ;
31941
31942 if (!args) SWIG_fail;
31943 swig_obj[0] = args;
31944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31945 if (!SWIG_IsOK(res1)) {
31946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31947 }
31948 arg1 = reinterpret_cast< wxWindow * >(argp1);
31949 {
31950 PyThreadState* __tstate = wxPyBeginAllowThreads();
31951 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
31952 wxPyEndAllowThreads(__tstate);
31953 if (PyErr_Occurred()) SWIG_fail;
31954 }
31955 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31956 return resultobj;
31957 fail:
31958 return NULL;
31959 }
31960
31961
31962 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31963 PyObject *resultobj = 0;
31964 wxWindow *arg1 = (wxWindow *) 0 ;
31965 bool arg2 = (bool) true ;
31966 bool result;
31967 void *argp1 = 0 ;
31968 int res1 = 0 ;
31969 bool val2 ;
31970 int ecode2 = 0 ;
31971 PyObject * obj0 = 0 ;
31972 PyObject * obj1 = 0 ;
31973 char * kwnames[] = {
31974 (char *) "self",(char *) "show", NULL
31975 };
31976
31977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
31978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31979 if (!SWIG_IsOK(res1)) {
31980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
31981 }
31982 arg1 = reinterpret_cast< wxWindow * >(argp1);
31983 if (obj1) {
31984 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31985 if (!SWIG_IsOK(ecode2)) {
31986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
31987 }
31988 arg2 = static_cast< bool >(val2);
31989 }
31990 {
31991 PyThreadState* __tstate = wxPyBeginAllowThreads();
31992 result = (bool)(arg1)->Show(arg2);
31993 wxPyEndAllowThreads(__tstate);
31994 if (PyErr_Occurred()) SWIG_fail;
31995 }
31996 {
31997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31998 }
31999 return resultobj;
32000 fail:
32001 return NULL;
32002 }
32003
32004
32005 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32006 PyObject *resultobj = 0;
32007 wxWindow *arg1 = (wxWindow *) 0 ;
32008 bool result;
32009 void *argp1 = 0 ;
32010 int res1 = 0 ;
32011 PyObject *swig_obj[1] ;
32012
32013 if (!args) SWIG_fail;
32014 swig_obj[0] = args;
32015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32016 if (!SWIG_IsOK(res1)) {
32017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32018 }
32019 arg1 = reinterpret_cast< wxWindow * >(argp1);
32020 {
32021 PyThreadState* __tstate = wxPyBeginAllowThreads();
32022 result = (bool)(arg1)->Hide();
32023 wxPyEndAllowThreads(__tstate);
32024 if (PyErr_Occurred()) SWIG_fail;
32025 }
32026 {
32027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32028 }
32029 return resultobj;
32030 fail:
32031 return NULL;
32032 }
32033
32034
32035 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32036 PyObject *resultobj = 0;
32037 wxWindow *arg1 = (wxWindow *) 0 ;
32038 bool arg2 = (bool) true ;
32039 bool result;
32040 void *argp1 = 0 ;
32041 int res1 = 0 ;
32042 bool val2 ;
32043 int ecode2 = 0 ;
32044 PyObject * obj0 = 0 ;
32045 PyObject * obj1 = 0 ;
32046 char * kwnames[] = {
32047 (char *) "self",(char *) "enable", NULL
32048 };
32049
32050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32052 if (!SWIG_IsOK(res1)) {
32053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32054 }
32055 arg1 = reinterpret_cast< wxWindow * >(argp1);
32056 if (obj1) {
32057 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32058 if (!SWIG_IsOK(ecode2)) {
32059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32060 }
32061 arg2 = static_cast< bool >(val2);
32062 }
32063 {
32064 PyThreadState* __tstate = wxPyBeginAllowThreads();
32065 result = (bool)(arg1)->Enable(arg2);
32066 wxPyEndAllowThreads(__tstate);
32067 if (PyErr_Occurred()) SWIG_fail;
32068 }
32069 {
32070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32071 }
32072 return resultobj;
32073 fail:
32074 return NULL;
32075 }
32076
32077
32078 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32079 PyObject *resultobj = 0;
32080 wxWindow *arg1 = (wxWindow *) 0 ;
32081 bool result;
32082 void *argp1 = 0 ;
32083 int res1 = 0 ;
32084 PyObject *swig_obj[1] ;
32085
32086 if (!args) SWIG_fail;
32087 swig_obj[0] = args;
32088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32089 if (!SWIG_IsOK(res1)) {
32090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32091 }
32092 arg1 = reinterpret_cast< wxWindow * >(argp1);
32093 {
32094 PyThreadState* __tstate = wxPyBeginAllowThreads();
32095 result = (bool)(arg1)->Disable();
32096 wxPyEndAllowThreads(__tstate);
32097 if (PyErr_Occurred()) SWIG_fail;
32098 }
32099 {
32100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32101 }
32102 return resultobj;
32103 fail:
32104 return NULL;
32105 }
32106
32107
32108 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32109 PyObject *resultobj = 0;
32110 wxWindow *arg1 = (wxWindow *) 0 ;
32111 bool result;
32112 void *argp1 = 0 ;
32113 int res1 = 0 ;
32114 PyObject *swig_obj[1] ;
32115
32116 if (!args) SWIG_fail;
32117 swig_obj[0] = args;
32118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32119 if (!SWIG_IsOK(res1)) {
32120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32121 }
32122 arg1 = reinterpret_cast< wxWindow * >(argp1);
32123 {
32124 PyThreadState* __tstate = wxPyBeginAllowThreads();
32125 result = (bool)((wxWindow const *)arg1)->IsShown();
32126 wxPyEndAllowThreads(__tstate);
32127 if (PyErr_Occurred()) SWIG_fail;
32128 }
32129 {
32130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32131 }
32132 return resultobj;
32133 fail:
32134 return NULL;
32135 }
32136
32137
32138 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32139 PyObject *resultobj = 0;
32140 wxWindow *arg1 = (wxWindow *) 0 ;
32141 bool result;
32142 void *argp1 = 0 ;
32143 int res1 = 0 ;
32144 PyObject *swig_obj[1] ;
32145
32146 if (!args) SWIG_fail;
32147 swig_obj[0] = args;
32148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32149 if (!SWIG_IsOK(res1)) {
32150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32151 }
32152 arg1 = reinterpret_cast< wxWindow * >(argp1);
32153 {
32154 PyThreadState* __tstate = wxPyBeginAllowThreads();
32155 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32156 wxPyEndAllowThreads(__tstate);
32157 if (PyErr_Occurred()) SWIG_fail;
32158 }
32159 {
32160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32161 }
32162 return resultobj;
32163 fail:
32164 return NULL;
32165 }
32166
32167
32168 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32169 PyObject *resultobj = 0;
32170 wxWindow *arg1 = (wxWindow *) 0 ;
32171 long arg2 ;
32172 void *argp1 = 0 ;
32173 int res1 = 0 ;
32174 long val2 ;
32175 int ecode2 = 0 ;
32176 PyObject * obj0 = 0 ;
32177 PyObject * obj1 = 0 ;
32178 char * kwnames[] = {
32179 (char *) "self",(char *) "style", NULL
32180 };
32181
32182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32184 if (!SWIG_IsOK(res1)) {
32185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32186 }
32187 arg1 = reinterpret_cast< wxWindow * >(argp1);
32188 ecode2 = SWIG_AsVal_long(obj1, &val2);
32189 if (!SWIG_IsOK(ecode2)) {
32190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32191 }
32192 arg2 = static_cast< long >(val2);
32193 {
32194 PyThreadState* __tstate = wxPyBeginAllowThreads();
32195 (arg1)->SetWindowStyleFlag(arg2);
32196 wxPyEndAllowThreads(__tstate);
32197 if (PyErr_Occurred()) SWIG_fail;
32198 }
32199 resultobj = SWIG_Py_Void();
32200 return resultobj;
32201 fail:
32202 return NULL;
32203 }
32204
32205
32206 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32207 PyObject *resultobj = 0;
32208 wxWindow *arg1 = (wxWindow *) 0 ;
32209 long result;
32210 void *argp1 = 0 ;
32211 int res1 = 0 ;
32212 PyObject *swig_obj[1] ;
32213
32214 if (!args) SWIG_fail;
32215 swig_obj[0] = args;
32216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32217 if (!SWIG_IsOK(res1)) {
32218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32219 }
32220 arg1 = reinterpret_cast< wxWindow * >(argp1);
32221 {
32222 PyThreadState* __tstate = wxPyBeginAllowThreads();
32223 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32224 wxPyEndAllowThreads(__tstate);
32225 if (PyErr_Occurred()) SWIG_fail;
32226 }
32227 resultobj = SWIG_From_long(static_cast< long >(result));
32228 return resultobj;
32229 fail:
32230 return NULL;
32231 }
32232
32233
32234 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32235 PyObject *resultobj = 0;
32236 wxWindow *arg1 = (wxWindow *) 0 ;
32237 int arg2 ;
32238 bool result;
32239 void *argp1 = 0 ;
32240 int res1 = 0 ;
32241 int val2 ;
32242 int ecode2 = 0 ;
32243 PyObject * obj0 = 0 ;
32244 PyObject * obj1 = 0 ;
32245 char * kwnames[] = {
32246 (char *) "self",(char *) "flag", NULL
32247 };
32248
32249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32251 if (!SWIG_IsOK(res1)) {
32252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32253 }
32254 arg1 = reinterpret_cast< wxWindow * >(argp1);
32255 ecode2 = SWIG_AsVal_int(obj1, &val2);
32256 if (!SWIG_IsOK(ecode2)) {
32257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32258 }
32259 arg2 = static_cast< int >(val2);
32260 {
32261 PyThreadState* __tstate = wxPyBeginAllowThreads();
32262 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32263 wxPyEndAllowThreads(__tstate);
32264 if (PyErr_Occurred()) SWIG_fail;
32265 }
32266 {
32267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32268 }
32269 return resultobj;
32270 fail:
32271 return NULL;
32272 }
32273
32274
32275 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32276 PyObject *resultobj = 0;
32277 wxWindow *arg1 = (wxWindow *) 0 ;
32278 bool result;
32279 void *argp1 = 0 ;
32280 int res1 = 0 ;
32281 PyObject *swig_obj[1] ;
32282
32283 if (!args) SWIG_fail;
32284 swig_obj[0] = args;
32285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32286 if (!SWIG_IsOK(res1)) {
32287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32288 }
32289 arg1 = reinterpret_cast< wxWindow * >(argp1);
32290 {
32291 PyThreadState* __tstate = wxPyBeginAllowThreads();
32292 result = (bool)((wxWindow const *)arg1)->IsRetained();
32293 wxPyEndAllowThreads(__tstate);
32294 if (PyErr_Occurred()) SWIG_fail;
32295 }
32296 {
32297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32298 }
32299 return resultobj;
32300 fail:
32301 return NULL;
32302 }
32303
32304
32305 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32306 PyObject *resultobj = 0;
32307 wxWindow *arg1 = (wxWindow *) 0 ;
32308 long arg2 ;
32309 void *argp1 = 0 ;
32310 int res1 = 0 ;
32311 long val2 ;
32312 int ecode2 = 0 ;
32313 PyObject * obj0 = 0 ;
32314 PyObject * obj1 = 0 ;
32315 char * kwnames[] = {
32316 (char *) "self",(char *) "exStyle", NULL
32317 };
32318
32319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32321 if (!SWIG_IsOK(res1)) {
32322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32323 }
32324 arg1 = reinterpret_cast< wxWindow * >(argp1);
32325 ecode2 = SWIG_AsVal_long(obj1, &val2);
32326 if (!SWIG_IsOK(ecode2)) {
32327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32328 }
32329 arg2 = static_cast< long >(val2);
32330 {
32331 PyThreadState* __tstate = wxPyBeginAllowThreads();
32332 (arg1)->SetExtraStyle(arg2);
32333 wxPyEndAllowThreads(__tstate);
32334 if (PyErr_Occurred()) SWIG_fail;
32335 }
32336 resultobj = SWIG_Py_Void();
32337 return resultobj;
32338 fail:
32339 return NULL;
32340 }
32341
32342
32343 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32344 PyObject *resultobj = 0;
32345 wxWindow *arg1 = (wxWindow *) 0 ;
32346 long result;
32347 void *argp1 = 0 ;
32348 int res1 = 0 ;
32349 PyObject *swig_obj[1] ;
32350
32351 if (!args) SWIG_fail;
32352 swig_obj[0] = args;
32353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32354 if (!SWIG_IsOK(res1)) {
32355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32356 }
32357 arg1 = reinterpret_cast< wxWindow * >(argp1);
32358 {
32359 PyThreadState* __tstate = wxPyBeginAllowThreads();
32360 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32361 wxPyEndAllowThreads(__tstate);
32362 if (PyErr_Occurred()) SWIG_fail;
32363 }
32364 resultobj = SWIG_From_long(static_cast< long >(result));
32365 return resultobj;
32366 fail:
32367 return NULL;
32368 }
32369
32370
32371 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32372 PyObject *resultobj = 0;
32373 wxWindow *arg1 = (wxWindow *) 0 ;
32374 bool arg2 = (bool) true ;
32375 void *argp1 = 0 ;
32376 int res1 = 0 ;
32377 bool val2 ;
32378 int ecode2 = 0 ;
32379 PyObject * obj0 = 0 ;
32380 PyObject * obj1 = 0 ;
32381 char * kwnames[] = {
32382 (char *) "self",(char *) "modal", NULL
32383 };
32384
32385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32387 if (!SWIG_IsOK(res1)) {
32388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32389 }
32390 arg1 = reinterpret_cast< wxWindow * >(argp1);
32391 if (obj1) {
32392 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32393 if (!SWIG_IsOK(ecode2)) {
32394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32395 }
32396 arg2 = static_cast< bool >(val2);
32397 }
32398 {
32399 PyThreadState* __tstate = wxPyBeginAllowThreads();
32400 (arg1)->MakeModal(arg2);
32401 wxPyEndAllowThreads(__tstate);
32402 if (PyErr_Occurred()) SWIG_fail;
32403 }
32404 resultobj = SWIG_Py_Void();
32405 return resultobj;
32406 fail:
32407 return NULL;
32408 }
32409
32410
32411 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32412 PyObject *resultobj = 0;
32413 wxWindow *arg1 = (wxWindow *) 0 ;
32414 bool arg2 ;
32415 void *argp1 = 0 ;
32416 int res1 = 0 ;
32417 bool val2 ;
32418 int ecode2 = 0 ;
32419 PyObject * obj0 = 0 ;
32420 PyObject * obj1 = 0 ;
32421 char * kwnames[] = {
32422 (char *) "self",(char *) "enableTheme", NULL
32423 };
32424
32425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32427 if (!SWIG_IsOK(res1)) {
32428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32429 }
32430 arg1 = reinterpret_cast< wxWindow * >(argp1);
32431 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32432 if (!SWIG_IsOK(ecode2)) {
32433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32434 }
32435 arg2 = static_cast< bool >(val2);
32436 {
32437 PyThreadState* __tstate = wxPyBeginAllowThreads();
32438 (arg1)->SetThemeEnabled(arg2);
32439 wxPyEndAllowThreads(__tstate);
32440 if (PyErr_Occurred()) SWIG_fail;
32441 }
32442 resultobj = SWIG_Py_Void();
32443 return resultobj;
32444 fail:
32445 return NULL;
32446 }
32447
32448
32449 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32450 PyObject *resultobj = 0;
32451 wxWindow *arg1 = (wxWindow *) 0 ;
32452 bool result;
32453 void *argp1 = 0 ;
32454 int res1 = 0 ;
32455 PyObject *swig_obj[1] ;
32456
32457 if (!args) SWIG_fail;
32458 swig_obj[0] = args;
32459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32460 if (!SWIG_IsOK(res1)) {
32461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32462 }
32463 arg1 = reinterpret_cast< wxWindow * >(argp1);
32464 {
32465 PyThreadState* __tstate = wxPyBeginAllowThreads();
32466 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32467 wxPyEndAllowThreads(__tstate);
32468 if (PyErr_Occurred()) SWIG_fail;
32469 }
32470 {
32471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32472 }
32473 return resultobj;
32474 fail:
32475 return NULL;
32476 }
32477
32478
32479 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32480 PyObject *resultobj = 0;
32481 wxWindow *arg1 = (wxWindow *) 0 ;
32482 void *argp1 = 0 ;
32483 int res1 = 0 ;
32484 PyObject *swig_obj[1] ;
32485
32486 if (!args) SWIG_fail;
32487 swig_obj[0] = args;
32488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32489 if (!SWIG_IsOK(res1)) {
32490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32491 }
32492 arg1 = reinterpret_cast< wxWindow * >(argp1);
32493 {
32494 PyThreadState* __tstate = wxPyBeginAllowThreads();
32495 (arg1)->SetFocus();
32496 wxPyEndAllowThreads(__tstate);
32497 if (PyErr_Occurred()) SWIG_fail;
32498 }
32499 resultobj = SWIG_Py_Void();
32500 return resultobj;
32501 fail:
32502 return NULL;
32503 }
32504
32505
32506 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32507 PyObject *resultobj = 0;
32508 wxWindow *arg1 = (wxWindow *) 0 ;
32509 void *argp1 = 0 ;
32510 int res1 = 0 ;
32511 PyObject *swig_obj[1] ;
32512
32513 if (!args) SWIG_fail;
32514 swig_obj[0] = args;
32515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32516 if (!SWIG_IsOK(res1)) {
32517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32518 }
32519 arg1 = reinterpret_cast< wxWindow * >(argp1);
32520 {
32521 PyThreadState* __tstate = wxPyBeginAllowThreads();
32522 (arg1)->SetFocusFromKbd();
32523 wxPyEndAllowThreads(__tstate);
32524 if (PyErr_Occurred()) SWIG_fail;
32525 }
32526 resultobj = SWIG_Py_Void();
32527 return resultobj;
32528 fail:
32529 return NULL;
32530 }
32531
32532
32533 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32534 PyObject *resultobj = 0;
32535 wxWindow *result = 0 ;
32536
32537 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32538 {
32539 if (!wxPyCheckForApp()) SWIG_fail;
32540 PyThreadState* __tstate = wxPyBeginAllowThreads();
32541 result = (wxWindow *)wxWindow::FindFocus();
32542 wxPyEndAllowThreads(__tstate);
32543 if (PyErr_Occurred()) SWIG_fail;
32544 }
32545 {
32546 resultobj = wxPyMake_wxObject(result, 0);
32547 }
32548 return resultobj;
32549 fail:
32550 return NULL;
32551 }
32552
32553
32554 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32555 PyObject *resultobj = 0;
32556 wxWindow *arg1 = (wxWindow *) 0 ;
32557 bool result;
32558 void *argp1 = 0 ;
32559 int res1 = 0 ;
32560 PyObject *swig_obj[1] ;
32561
32562 if (!args) SWIG_fail;
32563 swig_obj[0] = args;
32564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32565 if (!SWIG_IsOK(res1)) {
32566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32567 }
32568 arg1 = reinterpret_cast< wxWindow * >(argp1);
32569 {
32570 PyThreadState* __tstate = wxPyBeginAllowThreads();
32571 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32572 wxPyEndAllowThreads(__tstate);
32573 if (PyErr_Occurred()) SWIG_fail;
32574 }
32575 {
32576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32577 }
32578 return resultobj;
32579 fail:
32580 return NULL;
32581 }
32582
32583
32584 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32585 PyObject *resultobj = 0;
32586 wxWindow *arg1 = (wxWindow *) 0 ;
32587 bool result;
32588 void *argp1 = 0 ;
32589 int res1 = 0 ;
32590 PyObject *swig_obj[1] ;
32591
32592 if (!args) SWIG_fail;
32593 swig_obj[0] = args;
32594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32595 if (!SWIG_IsOK(res1)) {
32596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32597 }
32598 arg1 = reinterpret_cast< wxWindow * >(argp1);
32599 {
32600 PyThreadState* __tstate = wxPyBeginAllowThreads();
32601 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32602 wxPyEndAllowThreads(__tstate);
32603 if (PyErr_Occurred()) SWIG_fail;
32604 }
32605 {
32606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32607 }
32608 return resultobj;
32609 fail:
32610 return NULL;
32611 }
32612
32613
32614 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32615 PyObject *resultobj = 0;
32616 wxWindow *arg1 = (wxWindow *) 0 ;
32617 wxWindow *result = 0 ;
32618 void *argp1 = 0 ;
32619 int res1 = 0 ;
32620 PyObject *swig_obj[1] ;
32621
32622 if (!args) SWIG_fail;
32623 swig_obj[0] = args;
32624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32625 if (!SWIG_IsOK(res1)) {
32626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32627 }
32628 arg1 = reinterpret_cast< wxWindow * >(argp1);
32629 {
32630 PyThreadState* __tstate = wxPyBeginAllowThreads();
32631 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32632 wxPyEndAllowThreads(__tstate);
32633 if (PyErr_Occurred()) SWIG_fail;
32634 }
32635 {
32636 resultobj = wxPyMake_wxObject(result, 0);
32637 }
32638 return resultobj;
32639 fail:
32640 return NULL;
32641 }
32642
32643
32644 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32645 PyObject *resultobj = 0;
32646 wxWindow *arg1 = (wxWindow *) 0 ;
32647 wxWindow *arg2 = (wxWindow *) 0 ;
32648 wxWindow *result = 0 ;
32649 void *argp1 = 0 ;
32650 int res1 = 0 ;
32651 void *argp2 = 0 ;
32652 int res2 = 0 ;
32653 PyObject * obj0 = 0 ;
32654 PyObject * obj1 = 0 ;
32655 char * kwnames[] = {
32656 (char *) "self",(char *) "child", NULL
32657 };
32658
32659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32661 if (!SWIG_IsOK(res1)) {
32662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32663 }
32664 arg1 = reinterpret_cast< wxWindow * >(argp1);
32665 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32666 if (!SWIG_IsOK(res2)) {
32667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32668 }
32669 arg2 = reinterpret_cast< wxWindow * >(argp2);
32670 {
32671 PyThreadState* __tstate = wxPyBeginAllowThreads();
32672 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32673 wxPyEndAllowThreads(__tstate);
32674 if (PyErr_Occurred()) SWIG_fail;
32675 }
32676 {
32677 resultobj = wxPyMake_wxObject(result, 0);
32678 }
32679 return resultobj;
32680 fail:
32681 return NULL;
32682 }
32683
32684
32685 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32686 PyObject *resultobj = 0;
32687 wxWindow *arg1 = (wxWindow *) 0 ;
32688 wxWindow *arg2 = (wxWindow *) 0 ;
32689 void *argp1 = 0 ;
32690 int res1 = 0 ;
32691 void *argp2 = 0 ;
32692 int res2 = 0 ;
32693 PyObject * obj0 = 0 ;
32694 PyObject * obj1 = 0 ;
32695 char * kwnames[] = {
32696 (char *) "self",(char *) "win", NULL
32697 };
32698
32699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32701 if (!SWIG_IsOK(res1)) {
32702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32703 }
32704 arg1 = reinterpret_cast< wxWindow * >(argp1);
32705 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32706 if (!SWIG_IsOK(res2)) {
32707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32708 }
32709 arg2 = reinterpret_cast< wxWindow * >(argp2);
32710 {
32711 PyThreadState* __tstate = wxPyBeginAllowThreads();
32712 (arg1)->SetTmpDefaultItem(arg2);
32713 wxPyEndAllowThreads(__tstate);
32714 if (PyErr_Occurred()) SWIG_fail;
32715 }
32716 resultobj = SWIG_Py_Void();
32717 return resultobj;
32718 fail:
32719 return NULL;
32720 }
32721
32722
32723 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32724 PyObject *resultobj = 0;
32725 wxWindow *arg1 = (wxWindow *) 0 ;
32726 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32727 bool result;
32728 void *argp1 = 0 ;
32729 int res1 = 0 ;
32730 int val2 ;
32731 int ecode2 = 0 ;
32732 PyObject * obj0 = 0 ;
32733 PyObject * obj1 = 0 ;
32734 char * kwnames[] = {
32735 (char *) "self",(char *) "flags", NULL
32736 };
32737
32738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32740 if (!SWIG_IsOK(res1)) {
32741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32742 }
32743 arg1 = reinterpret_cast< wxWindow * >(argp1);
32744 if (obj1) {
32745 ecode2 = SWIG_AsVal_int(obj1, &val2);
32746 if (!SWIG_IsOK(ecode2)) {
32747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32748 }
32749 arg2 = static_cast< int >(val2);
32750 }
32751 {
32752 PyThreadState* __tstate = wxPyBeginAllowThreads();
32753 result = (bool)(arg1)->Navigate(arg2);
32754 wxPyEndAllowThreads(__tstate);
32755 if (PyErr_Occurred()) SWIG_fail;
32756 }
32757 {
32758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32759 }
32760 return resultobj;
32761 fail:
32762 return NULL;
32763 }
32764
32765
32766 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32767 PyObject *resultobj = 0;
32768 wxWindow *arg1 = (wxWindow *) 0 ;
32769 wxWindow *arg2 = (wxWindow *) 0 ;
32770 void *argp1 = 0 ;
32771 int res1 = 0 ;
32772 void *argp2 = 0 ;
32773 int res2 = 0 ;
32774 PyObject * obj0 = 0 ;
32775 PyObject * obj1 = 0 ;
32776 char * kwnames[] = {
32777 (char *) "self",(char *) "win", NULL
32778 };
32779
32780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32782 if (!SWIG_IsOK(res1)) {
32783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32784 }
32785 arg1 = reinterpret_cast< wxWindow * >(argp1);
32786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32787 if (!SWIG_IsOK(res2)) {
32788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32789 }
32790 arg2 = reinterpret_cast< wxWindow * >(argp2);
32791 {
32792 PyThreadState* __tstate = wxPyBeginAllowThreads();
32793 (arg1)->MoveAfterInTabOrder(arg2);
32794 wxPyEndAllowThreads(__tstate);
32795 if (PyErr_Occurred()) SWIG_fail;
32796 }
32797 resultobj = SWIG_Py_Void();
32798 return resultobj;
32799 fail:
32800 return NULL;
32801 }
32802
32803
32804 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32805 PyObject *resultobj = 0;
32806 wxWindow *arg1 = (wxWindow *) 0 ;
32807 wxWindow *arg2 = (wxWindow *) 0 ;
32808 void *argp1 = 0 ;
32809 int res1 = 0 ;
32810 void *argp2 = 0 ;
32811 int res2 = 0 ;
32812 PyObject * obj0 = 0 ;
32813 PyObject * obj1 = 0 ;
32814 char * kwnames[] = {
32815 (char *) "self",(char *) "win", NULL
32816 };
32817
32818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32820 if (!SWIG_IsOK(res1)) {
32821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32822 }
32823 arg1 = reinterpret_cast< wxWindow * >(argp1);
32824 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32825 if (!SWIG_IsOK(res2)) {
32826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32827 }
32828 arg2 = reinterpret_cast< wxWindow * >(argp2);
32829 {
32830 PyThreadState* __tstate = wxPyBeginAllowThreads();
32831 (arg1)->MoveBeforeInTabOrder(arg2);
32832 wxPyEndAllowThreads(__tstate);
32833 if (PyErr_Occurred()) SWIG_fail;
32834 }
32835 resultobj = SWIG_Py_Void();
32836 return resultobj;
32837 fail:
32838 return NULL;
32839 }
32840
32841
32842 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32843 PyObject *resultobj = 0;
32844 wxWindow *arg1 = (wxWindow *) 0 ;
32845 PyObject *result = 0 ;
32846 void *argp1 = 0 ;
32847 int res1 = 0 ;
32848 PyObject *swig_obj[1] ;
32849
32850 if (!args) SWIG_fail;
32851 swig_obj[0] = args;
32852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32853 if (!SWIG_IsOK(res1)) {
32854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32855 }
32856 arg1 = reinterpret_cast< wxWindow * >(argp1);
32857 {
32858 PyThreadState* __tstate = wxPyBeginAllowThreads();
32859 result = (PyObject *)wxWindow_GetChildren(arg1);
32860 wxPyEndAllowThreads(__tstate);
32861 if (PyErr_Occurred()) SWIG_fail;
32862 }
32863 resultobj = result;
32864 return resultobj;
32865 fail:
32866 return NULL;
32867 }
32868
32869
32870 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32871 PyObject *resultobj = 0;
32872 wxWindow *arg1 = (wxWindow *) 0 ;
32873 wxWindow *result = 0 ;
32874 void *argp1 = 0 ;
32875 int res1 = 0 ;
32876 PyObject *swig_obj[1] ;
32877
32878 if (!args) SWIG_fail;
32879 swig_obj[0] = args;
32880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32881 if (!SWIG_IsOK(res1)) {
32882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32883 }
32884 arg1 = reinterpret_cast< wxWindow * >(argp1);
32885 {
32886 PyThreadState* __tstate = wxPyBeginAllowThreads();
32887 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32888 wxPyEndAllowThreads(__tstate);
32889 if (PyErr_Occurred()) SWIG_fail;
32890 }
32891 {
32892 resultobj = wxPyMake_wxObject(result, 0);
32893 }
32894 return resultobj;
32895 fail:
32896 return NULL;
32897 }
32898
32899
32900 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32901 PyObject *resultobj = 0;
32902 wxWindow *arg1 = (wxWindow *) 0 ;
32903 wxWindow *result = 0 ;
32904 void *argp1 = 0 ;
32905 int res1 = 0 ;
32906 PyObject *swig_obj[1] ;
32907
32908 if (!args) SWIG_fail;
32909 swig_obj[0] = args;
32910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32911 if (!SWIG_IsOK(res1)) {
32912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32913 }
32914 arg1 = reinterpret_cast< wxWindow * >(argp1);
32915 {
32916 PyThreadState* __tstate = wxPyBeginAllowThreads();
32917 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32918 wxPyEndAllowThreads(__tstate);
32919 if (PyErr_Occurred()) SWIG_fail;
32920 }
32921 {
32922 resultobj = wxPyMake_wxObject(result, 0);
32923 }
32924 return resultobj;
32925 fail:
32926 return NULL;
32927 }
32928
32929
32930 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32931 PyObject *resultobj = 0;
32932 wxWindow *arg1 = (wxWindow *) 0 ;
32933 bool result;
32934 void *argp1 = 0 ;
32935 int res1 = 0 ;
32936 PyObject *swig_obj[1] ;
32937
32938 if (!args) SWIG_fail;
32939 swig_obj[0] = args;
32940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32941 if (!SWIG_IsOK(res1)) {
32942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
32943 }
32944 arg1 = reinterpret_cast< wxWindow * >(argp1);
32945 {
32946 PyThreadState* __tstate = wxPyBeginAllowThreads();
32947 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
32948 wxPyEndAllowThreads(__tstate);
32949 if (PyErr_Occurred()) SWIG_fail;
32950 }
32951 {
32952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32953 }
32954 return resultobj;
32955 fail:
32956 return NULL;
32957 }
32958
32959
32960 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32961 PyObject *resultobj = 0;
32962 wxWindow *arg1 = (wxWindow *) 0 ;
32963 wxWindow *arg2 = (wxWindow *) 0 ;
32964 bool result;
32965 void *argp1 = 0 ;
32966 int res1 = 0 ;
32967 void *argp2 = 0 ;
32968 int res2 = 0 ;
32969 PyObject * obj0 = 0 ;
32970 PyObject * obj1 = 0 ;
32971 char * kwnames[] = {
32972 (char *) "self",(char *) "newParent", NULL
32973 };
32974
32975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
32976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32977 if (!SWIG_IsOK(res1)) {
32978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
32979 }
32980 arg1 = reinterpret_cast< wxWindow * >(argp1);
32981 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32982 if (!SWIG_IsOK(res2)) {
32983 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
32984 }
32985 arg2 = reinterpret_cast< wxWindow * >(argp2);
32986 {
32987 PyThreadState* __tstate = wxPyBeginAllowThreads();
32988 result = (bool)(arg1)->Reparent(arg2);
32989 wxPyEndAllowThreads(__tstate);
32990 if (PyErr_Occurred()) SWIG_fail;
32991 }
32992 {
32993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32994 }
32995 return resultobj;
32996 fail:
32997 return NULL;
32998 }
32999
33000
33001 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33002 PyObject *resultobj = 0;
33003 wxWindow *arg1 = (wxWindow *) 0 ;
33004 wxWindow *arg2 = (wxWindow *) 0 ;
33005 void *argp1 = 0 ;
33006 int res1 = 0 ;
33007 void *argp2 = 0 ;
33008 int res2 = 0 ;
33009 PyObject * obj0 = 0 ;
33010 PyObject * obj1 = 0 ;
33011 char * kwnames[] = {
33012 (char *) "self",(char *) "child", NULL
33013 };
33014
33015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33017 if (!SWIG_IsOK(res1)) {
33018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33019 }
33020 arg1 = reinterpret_cast< wxWindow * >(argp1);
33021 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33022 if (!SWIG_IsOK(res2)) {
33023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33024 }
33025 arg2 = reinterpret_cast< wxWindow * >(argp2);
33026 {
33027 PyThreadState* __tstate = wxPyBeginAllowThreads();
33028 (arg1)->AddChild(arg2);
33029 wxPyEndAllowThreads(__tstate);
33030 if (PyErr_Occurred()) SWIG_fail;
33031 }
33032 resultobj = SWIG_Py_Void();
33033 return resultobj;
33034 fail:
33035 return NULL;
33036 }
33037
33038
33039 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33040 PyObject *resultobj = 0;
33041 wxWindow *arg1 = (wxWindow *) 0 ;
33042 wxWindow *arg2 = (wxWindow *) 0 ;
33043 void *argp1 = 0 ;
33044 int res1 = 0 ;
33045 void *argp2 = 0 ;
33046 int res2 = 0 ;
33047 PyObject * obj0 = 0 ;
33048 PyObject * obj1 = 0 ;
33049 char * kwnames[] = {
33050 (char *) "self",(char *) "child", NULL
33051 };
33052
33053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33055 if (!SWIG_IsOK(res1)) {
33056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33057 }
33058 arg1 = reinterpret_cast< wxWindow * >(argp1);
33059 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33060 if (!SWIG_IsOK(res2)) {
33061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33062 }
33063 arg2 = reinterpret_cast< wxWindow * >(argp2);
33064 {
33065 PyThreadState* __tstate = wxPyBeginAllowThreads();
33066 (arg1)->RemoveChild(arg2);
33067 wxPyEndAllowThreads(__tstate);
33068 if (PyErr_Occurred()) SWIG_fail;
33069 }
33070 resultobj = SWIG_Py_Void();
33071 return resultobj;
33072 fail:
33073 return NULL;
33074 }
33075
33076
33077 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33078 PyObject *resultobj = 0;
33079 wxWindow *arg1 = (wxWindow *) 0 ;
33080 long arg2 ;
33081 wxWindow *result = 0 ;
33082 void *argp1 = 0 ;
33083 int res1 = 0 ;
33084 long val2 ;
33085 int ecode2 = 0 ;
33086 PyObject * obj0 = 0 ;
33087 PyObject * obj1 = 0 ;
33088 char * kwnames[] = {
33089 (char *) "self",(char *) "winid", NULL
33090 };
33091
33092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33094 if (!SWIG_IsOK(res1)) {
33095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33096 }
33097 arg1 = reinterpret_cast< wxWindow * >(argp1);
33098 ecode2 = SWIG_AsVal_long(obj1, &val2);
33099 if (!SWIG_IsOK(ecode2)) {
33100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33101 }
33102 arg2 = static_cast< long >(val2);
33103 {
33104 PyThreadState* __tstate = wxPyBeginAllowThreads();
33105 result = (wxWindow *)(arg1)->FindWindow(arg2);
33106 wxPyEndAllowThreads(__tstate);
33107 if (PyErr_Occurred()) SWIG_fail;
33108 }
33109 {
33110 resultobj = wxPyMake_wxObject(result, 0);
33111 }
33112 return resultobj;
33113 fail:
33114 return NULL;
33115 }
33116
33117
33118 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33119 PyObject *resultobj = 0;
33120 wxWindow *arg1 = (wxWindow *) 0 ;
33121 wxString *arg2 = 0 ;
33122 wxWindow *result = 0 ;
33123 void *argp1 = 0 ;
33124 int res1 = 0 ;
33125 bool temp2 = false ;
33126 PyObject * obj0 = 0 ;
33127 PyObject * obj1 = 0 ;
33128 char * kwnames[] = {
33129 (char *) "self",(char *) "name", NULL
33130 };
33131
33132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33134 if (!SWIG_IsOK(res1)) {
33135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33136 }
33137 arg1 = reinterpret_cast< wxWindow * >(argp1);
33138 {
33139 arg2 = wxString_in_helper(obj1);
33140 if (arg2 == NULL) SWIG_fail;
33141 temp2 = true;
33142 }
33143 {
33144 PyThreadState* __tstate = wxPyBeginAllowThreads();
33145 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33146 wxPyEndAllowThreads(__tstate);
33147 if (PyErr_Occurred()) SWIG_fail;
33148 }
33149 {
33150 resultobj = wxPyMake_wxObject(result, 0);
33151 }
33152 {
33153 if (temp2)
33154 delete arg2;
33155 }
33156 return resultobj;
33157 fail:
33158 {
33159 if (temp2)
33160 delete arg2;
33161 }
33162 return NULL;
33163 }
33164
33165
33166 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33167 PyObject *resultobj = 0;
33168 wxWindow *arg1 = (wxWindow *) 0 ;
33169 wxEvtHandler *result = 0 ;
33170 void *argp1 = 0 ;
33171 int res1 = 0 ;
33172 PyObject *swig_obj[1] ;
33173
33174 if (!args) SWIG_fail;
33175 swig_obj[0] = args;
33176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33177 if (!SWIG_IsOK(res1)) {
33178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33179 }
33180 arg1 = reinterpret_cast< wxWindow * >(argp1);
33181 {
33182 PyThreadState* __tstate = wxPyBeginAllowThreads();
33183 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33184 wxPyEndAllowThreads(__tstate);
33185 if (PyErr_Occurred()) SWIG_fail;
33186 }
33187 {
33188 resultobj = wxPyMake_wxObject(result, 0);
33189 }
33190 return resultobj;
33191 fail:
33192 return NULL;
33193 }
33194
33195
33196 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33197 PyObject *resultobj = 0;
33198 wxWindow *arg1 = (wxWindow *) 0 ;
33199 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33200 void *argp1 = 0 ;
33201 int res1 = 0 ;
33202 void *argp2 = 0 ;
33203 int res2 = 0 ;
33204 PyObject * obj0 = 0 ;
33205 PyObject * obj1 = 0 ;
33206 char * kwnames[] = {
33207 (char *) "self",(char *) "handler", NULL
33208 };
33209
33210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33212 if (!SWIG_IsOK(res1)) {
33213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33214 }
33215 arg1 = reinterpret_cast< wxWindow * >(argp1);
33216 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33217 if (!SWIG_IsOK(res2)) {
33218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33219 }
33220 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33221 {
33222 PyThreadState* __tstate = wxPyBeginAllowThreads();
33223 (arg1)->SetEventHandler(arg2);
33224 wxPyEndAllowThreads(__tstate);
33225 if (PyErr_Occurred()) SWIG_fail;
33226 }
33227 resultobj = SWIG_Py_Void();
33228 return resultobj;
33229 fail:
33230 return NULL;
33231 }
33232
33233
33234 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33235 PyObject *resultobj = 0;
33236 wxWindow *arg1 = (wxWindow *) 0 ;
33237 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33238 void *argp1 = 0 ;
33239 int res1 = 0 ;
33240 void *argp2 = 0 ;
33241 int res2 = 0 ;
33242 PyObject * obj0 = 0 ;
33243 PyObject * obj1 = 0 ;
33244 char * kwnames[] = {
33245 (char *) "self",(char *) "handler", NULL
33246 };
33247
33248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33250 if (!SWIG_IsOK(res1)) {
33251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33252 }
33253 arg1 = reinterpret_cast< wxWindow * >(argp1);
33254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33255 if (!SWIG_IsOK(res2)) {
33256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33257 }
33258 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33259 {
33260 PyThreadState* __tstate = wxPyBeginAllowThreads();
33261 (arg1)->PushEventHandler(arg2);
33262 wxPyEndAllowThreads(__tstate);
33263 if (PyErr_Occurred()) SWIG_fail;
33264 }
33265 resultobj = SWIG_Py_Void();
33266 return resultobj;
33267 fail:
33268 return NULL;
33269 }
33270
33271
33272 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33273 PyObject *resultobj = 0;
33274 wxWindow *arg1 = (wxWindow *) 0 ;
33275 bool arg2 = (bool) false ;
33276 wxEvtHandler *result = 0 ;
33277 void *argp1 = 0 ;
33278 int res1 = 0 ;
33279 bool val2 ;
33280 int ecode2 = 0 ;
33281 PyObject * obj0 = 0 ;
33282 PyObject * obj1 = 0 ;
33283 char * kwnames[] = {
33284 (char *) "self",(char *) "deleteHandler", NULL
33285 };
33286
33287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33289 if (!SWIG_IsOK(res1)) {
33290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33291 }
33292 arg1 = reinterpret_cast< wxWindow * >(argp1);
33293 if (obj1) {
33294 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33295 if (!SWIG_IsOK(ecode2)) {
33296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33297 }
33298 arg2 = static_cast< bool >(val2);
33299 }
33300 {
33301 PyThreadState* __tstate = wxPyBeginAllowThreads();
33302 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33303 wxPyEndAllowThreads(__tstate);
33304 if (PyErr_Occurred()) SWIG_fail;
33305 }
33306 {
33307 resultobj = wxPyMake_wxObject(result, 0);
33308 }
33309 return resultobj;
33310 fail:
33311 return NULL;
33312 }
33313
33314
33315 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33316 PyObject *resultobj = 0;
33317 wxWindow *arg1 = (wxWindow *) 0 ;
33318 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33319 bool result;
33320 void *argp1 = 0 ;
33321 int res1 = 0 ;
33322 void *argp2 = 0 ;
33323 int res2 = 0 ;
33324 PyObject * obj0 = 0 ;
33325 PyObject * obj1 = 0 ;
33326 char * kwnames[] = {
33327 (char *) "self",(char *) "handler", NULL
33328 };
33329
33330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33332 if (!SWIG_IsOK(res1)) {
33333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33334 }
33335 arg1 = reinterpret_cast< wxWindow * >(argp1);
33336 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33337 if (!SWIG_IsOK(res2)) {
33338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33339 }
33340 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33341 {
33342 PyThreadState* __tstate = wxPyBeginAllowThreads();
33343 result = (bool)(arg1)->RemoveEventHandler(arg2);
33344 wxPyEndAllowThreads(__tstate);
33345 if (PyErr_Occurred()) SWIG_fail;
33346 }
33347 {
33348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33349 }
33350 return resultobj;
33351 fail:
33352 return NULL;
33353 }
33354
33355
33356 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33357 PyObject *resultobj = 0;
33358 wxWindow *arg1 = (wxWindow *) 0 ;
33359 wxValidator *arg2 = 0 ;
33360 void *argp1 = 0 ;
33361 int res1 = 0 ;
33362 void *argp2 = 0 ;
33363 int res2 = 0 ;
33364 PyObject * obj0 = 0 ;
33365 PyObject * obj1 = 0 ;
33366 char * kwnames[] = {
33367 (char *) "self",(char *) "validator", NULL
33368 };
33369
33370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33372 if (!SWIG_IsOK(res1)) {
33373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33374 }
33375 arg1 = reinterpret_cast< wxWindow * >(argp1);
33376 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33377 if (!SWIG_IsOK(res2)) {
33378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33379 }
33380 if (!argp2) {
33381 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33382 }
33383 arg2 = reinterpret_cast< wxValidator * >(argp2);
33384 {
33385 PyThreadState* __tstate = wxPyBeginAllowThreads();
33386 (arg1)->SetValidator((wxValidator const &)*arg2);
33387 wxPyEndAllowThreads(__tstate);
33388 if (PyErr_Occurred()) SWIG_fail;
33389 }
33390 resultobj = SWIG_Py_Void();
33391 return resultobj;
33392 fail:
33393 return NULL;
33394 }
33395
33396
33397 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33398 PyObject *resultobj = 0;
33399 wxWindow *arg1 = (wxWindow *) 0 ;
33400 wxValidator *result = 0 ;
33401 void *argp1 = 0 ;
33402 int res1 = 0 ;
33403 PyObject *swig_obj[1] ;
33404
33405 if (!args) SWIG_fail;
33406 swig_obj[0] = args;
33407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33408 if (!SWIG_IsOK(res1)) {
33409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33410 }
33411 arg1 = reinterpret_cast< wxWindow * >(argp1);
33412 {
33413 PyThreadState* __tstate = wxPyBeginAllowThreads();
33414 result = (wxValidator *)(arg1)->GetValidator();
33415 wxPyEndAllowThreads(__tstate);
33416 if (PyErr_Occurred()) SWIG_fail;
33417 }
33418 {
33419 resultobj = wxPyMake_wxObject(result, (bool)0);
33420 }
33421 return resultobj;
33422 fail:
33423 return NULL;
33424 }
33425
33426
33427 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33428 PyObject *resultobj = 0;
33429 wxWindow *arg1 = (wxWindow *) 0 ;
33430 bool result;
33431 void *argp1 = 0 ;
33432 int res1 = 0 ;
33433 PyObject *swig_obj[1] ;
33434
33435 if (!args) SWIG_fail;
33436 swig_obj[0] = args;
33437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33438 if (!SWIG_IsOK(res1)) {
33439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33440 }
33441 arg1 = reinterpret_cast< wxWindow * >(argp1);
33442 {
33443 PyThreadState* __tstate = wxPyBeginAllowThreads();
33444 result = (bool)(arg1)->Validate();
33445 wxPyEndAllowThreads(__tstate);
33446 if (PyErr_Occurred()) SWIG_fail;
33447 }
33448 {
33449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33450 }
33451 return resultobj;
33452 fail:
33453 return NULL;
33454 }
33455
33456
33457 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33458 PyObject *resultobj = 0;
33459 wxWindow *arg1 = (wxWindow *) 0 ;
33460 bool result;
33461 void *argp1 = 0 ;
33462 int res1 = 0 ;
33463 PyObject *swig_obj[1] ;
33464
33465 if (!args) SWIG_fail;
33466 swig_obj[0] = args;
33467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33468 if (!SWIG_IsOK(res1)) {
33469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33470 }
33471 arg1 = reinterpret_cast< wxWindow * >(argp1);
33472 {
33473 PyThreadState* __tstate = wxPyBeginAllowThreads();
33474 result = (bool)(arg1)->TransferDataToWindow();
33475 wxPyEndAllowThreads(__tstate);
33476 if (PyErr_Occurred()) SWIG_fail;
33477 }
33478 {
33479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33480 }
33481 return resultobj;
33482 fail:
33483 return NULL;
33484 }
33485
33486
33487 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33488 PyObject *resultobj = 0;
33489 wxWindow *arg1 = (wxWindow *) 0 ;
33490 bool result;
33491 void *argp1 = 0 ;
33492 int res1 = 0 ;
33493 PyObject *swig_obj[1] ;
33494
33495 if (!args) SWIG_fail;
33496 swig_obj[0] = args;
33497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33498 if (!SWIG_IsOK(res1)) {
33499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33500 }
33501 arg1 = reinterpret_cast< wxWindow * >(argp1);
33502 {
33503 PyThreadState* __tstate = wxPyBeginAllowThreads();
33504 result = (bool)(arg1)->TransferDataFromWindow();
33505 wxPyEndAllowThreads(__tstate);
33506 if (PyErr_Occurred()) SWIG_fail;
33507 }
33508 {
33509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33510 }
33511 return resultobj;
33512 fail:
33513 return NULL;
33514 }
33515
33516
33517 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33518 PyObject *resultobj = 0;
33519 wxWindow *arg1 = (wxWindow *) 0 ;
33520 void *argp1 = 0 ;
33521 int res1 = 0 ;
33522 PyObject *swig_obj[1] ;
33523
33524 if (!args) SWIG_fail;
33525 swig_obj[0] = args;
33526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33527 if (!SWIG_IsOK(res1)) {
33528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33529 }
33530 arg1 = reinterpret_cast< wxWindow * >(argp1);
33531 {
33532 PyThreadState* __tstate = wxPyBeginAllowThreads();
33533 (arg1)->InitDialog();
33534 wxPyEndAllowThreads(__tstate);
33535 if (PyErr_Occurred()) SWIG_fail;
33536 }
33537 resultobj = SWIG_Py_Void();
33538 return resultobj;
33539 fail:
33540 return NULL;
33541 }
33542
33543
33544 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33545 PyObject *resultobj = 0;
33546 wxWindow *arg1 = (wxWindow *) 0 ;
33547 wxAcceleratorTable *arg2 = 0 ;
33548 void *argp1 = 0 ;
33549 int res1 = 0 ;
33550 void *argp2 = 0 ;
33551 int res2 = 0 ;
33552 PyObject * obj0 = 0 ;
33553 PyObject * obj1 = 0 ;
33554 char * kwnames[] = {
33555 (char *) "self",(char *) "accel", NULL
33556 };
33557
33558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33560 if (!SWIG_IsOK(res1)) {
33561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33562 }
33563 arg1 = reinterpret_cast< wxWindow * >(argp1);
33564 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33565 if (!SWIG_IsOK(res2)) {
33566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33567 }
33568 if (!argp2) {
33569 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33570 }
33571 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33572 {
33573 PyThreadState* __tstate = wxPyBeginAllowThreads();
33574 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33575 wxPyEndAllowThreads(__tstate);
33576 if (PyErr_Occurred()) SWIG_fail;
33577 }
33578 resultobj = SWIG_Py_Void();
33579 return resultobj;
33580 fail:
33581 return NULL;
33582 }
33583
33584
33585 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33586 PyObject *resultobj = 0;
33587 wxWindow *arg1 = (wxWindow *) 0 ;
33588 wxAcceleratorTable *result = 0 ;
33589 void *argp1 = 0 ;
33590 int res1 = 0 ;
33591 PyObject *swig_obj[1] ;
33592
33593 if (!args) SWIG_fail;
33594 swig_obj[0] = args;
33595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33596 if (!SWIG_IsOK(res1)) {
33597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33598 }
33599 arg1 = reinterpret_cast< wxWindow * >(argp1);
33600 {
33601 PyThreadState* __tstate = wxPyBeginAllowThreads();
33602 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33603 wxPyEndAllowThreads(__tstate);
33604 if (PyErr_Occurred()) SWIG_fail;
33605 }
33606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33607 return resultobj;
33608 fail:
33609 return NULL;
33610 }
33611
33612
33613 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33614 PyObject *resultobj = 0;
33615 wxWindow *arg1 = (wxWindow *) 0 ;
33616 int arg2 ;
33617 int arg3 ;
33618 int arg4 ;
33619 bool result;
33620 void *argp1 = 0 ;
33621 int res1 = 0 ;
33622 int val2 ;
33623 int ecode2 = 0 ;
33624 int val3 ;
33625 int ecode3 = 0 ;
33626 int val4 ;
33627 int ecode4 = 0 ;
33628 PyObject * obj0 = 0 ;
33629 PyObject * obj1 = 0 ;
33630 PyObject * obj2 = 0 ;
33631 PyObject * obj3 = 0 ;
33632 char * kwnames[] = {
33633 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33634 };
33635
33636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33638 if (!SWIG_IsOK(res1)) {
33639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33640 }
33641 arg1 = reinterpret_cast< wxWindow * >(argp1);
33642 ecode2 = SWIG_AsVal_int(obj1, &val2);
33643 if (!SWIG_IsOK(ecode2)) {
33644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33645 }
33646 arg2 = static_cast< int >(val2);
33647 ecode3 = SWIG_AsVal_int(obj2, &val3);
33648 if (!SWIG_IsOK(ecode3)) {
33649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33650 }
33651 arg3 = static_cast< int >(val3);
33652 ecode4 = SWIG_AsVal_int(obj3, &val4);
33653 if (!SWIG_IsOK(ecode4)) {
33654 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33655 }
33656 arg4 = static_cast< int >(val4);
33657 {
33658 PyThreadState* __tstate = wxPyBeginAllowThreads();
33659 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33660 wxPyEndAllowThreads(__tstate);
33661 if (PyErr_Occurred()) SWIG_fail;
33662 }
33663 {
33664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33665 }
33666 return resultobj;
33667 fail:
33668 return NULL;
33669 }
33670
33671
33672 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33673 PyObject *resultobj = 0;
33674 wxWindow *arg1 = (wxWindow *) 0 ;
33675 int arg2 ;
33676 bool result;
33677 void *argp1 = 0 ;
33678 int res1 = 0 ;
33679 int val2 ;
33680 int ecode2 = 0 ;
33681 PyObject * obj0 = 0 ;
33682 PyObject * obj1 = 0 ;
33683 char * kwnames[] = {
33684 (char *) "self",(char *) "hotkeyId", NULL
33685 };
33686
33687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33689 if (!SWIG_IsOK(res1)) {
33690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33691 }
33692 arg1 = reinterpret_cast< wxWindow * >(argp1);
33693 ecode2 = SWIG_AsVal_int(obj1, &val2);
33694 if (!SWIG_IsOK(ecode2)) {
33695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33696 }
33697 arg2 = static_cast< int >(val2);
33698 {
33699 PyThreadState* __tstate = wxPyBeginAllowThreads();
33700 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33701 wxPyEndAllowThreads(__tstate);
33702 if (PyErr_Occurred()) SWIG_fail;
33703 }
33704 {
33705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33706 }
33707 return resultobj;
33708 fail:
33709 return NULL;
33710 }
33711
33712
33713 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33714 PyObject *resultobj = 0;
33715 wxWindow *arg1 = (wxWindow *) 0 ;
33716 wxPoint *arg2 = 0 ;
33717 wxPoint result;
33718 void *argp1 = 0 ;
33719 int res1 = 0 ;
33720 wxPoint temp2 ;
33721 PyObject * obj0 = 0 ;
33722 PyObject * obj1 = 0 ;
33723 char * kwnames[] = {
33724 (char *) "self",(char *) "pt", NULL
33725 };
33726
33727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33729 if (!SWIG_IsOK(res1)) {
33730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33731 }
33732 arg1 = reinterpret_cast< wxWindow * >(argp1);
33733 {
33734 arg2 = &temp2;
33735 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33736 }
33737 {
33738 PyThreadState* __tstate = wxPyBeginAllowThreads();
33739 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33740 wxPyEndAllowThreads(__tstate);
33741 if (PyErr_Occurred()) SWIG_fail;
33742 }
33743 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33744 return resultobj;
33745 fail:
33746 return NULL;
33747 }
33748
33749
33750 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33751 PyObject *resultobj = 0;
33752 wxWindow *arg1 = (wxWindow *) 0 ;
33753 wxSize *arg2 = 0 ;
33754 wxSize result;
33755 void *argp1 = 0 ;
33756 int res1 = 0 ;
33757 wxSize temp2 ;
33758 PyObject * obj0 = 0 ;
33759 PyObject * obj1 = 0 ;
33760 char * kwnames[] = {
33761 (char *) "self",(char *) "sz", NULL
33762 };
33763
33764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33766 if (!SWIG_IsOK(res1)) {
33767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33768 }
33769 arg1 = reinterpret_cast< wxWindow * >(argp1);
33770 {
33771 arg2 = &temp2;
33772 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33773 }
33774 {
33775 PyThreadState* __tstate = wxPyBeginAllowThreads();
33776 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33777 wxPyEndAllowThreads(__tstate);
33778 if (PyErr_Occurred()) SWIG_fail;
33779 }
33780 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33781 return resultobj;
33782 fail:
33783 return NULL;
33784 }
33785
33786
33787 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33788 PyObject *resultobj = 0;
33789 wxWindow *arg1 = (wxWindow *) 0 ;
33790 wxPoint *arg2 = 0 ;
33791 wxPoint result;
33792 void *argp1 = 0 ;
33793 int res1 = 0 ;
33794 wxPoint temp2 ;
33795 PyObject * obj0 = 0 ;
33796 PyObject * obj1 = 0 ;
33797 char * kwnames[] = {
33798 (char *) "self",(char *) "pt", NULL
33799 };
33800
33801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33803 if (!SWIG_IsOK(res1)) {
33804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33805 }
33806 arg1 = reinterpret_cast< wxWindow * >(argp1);
33807 {
33808 arg2 = &temp2;
33809 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33810 }
33811 {
33812 PyThreadState* __tstate = wxPyBeginAllowThreads();
33813 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33814 wxPyEndAllowThreads(__tstate);
33815 if (PyErr_Occurred()) SWIG_fail;
33816 }
33817 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33818 return resultobj;
33819 fail:
33820 return NULL;
33821 }
33822
33823
33824 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33825 PyObject *resultobj = 0;
33826 wxWindow *arg1 = (wxWindow *) 0 ;
33827 wxSize *arg2 = 0 ;
33828 wxSize result;
33829 void *argp1 = 0 ;
33830 int res1 = 0 ;
33831 wxSize temp2 ;
33832 PyObject * obj0 = 0 ;
33833 PyObject * obj1 = 0 ;
33834 char * kwnames[] = {
33835 (char *) "self",(char *) "sz", NULL
33836 };
33837
33838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33840 if (!SWIG_IsOK(res1)) {
33841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33842 }
33843 arg1 = reinterpret_cast< wxWindow * >(argp1);
33844 {
33845 arg2 = &temp2;
33846 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33847 }
33848 {
33849 PyThreadState* __tstate = wxPyBeginAllowThreads();
33850 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33851 wxPyEndAllowThreads(__tstate);
33852 if (PyErr_Occurred()) SWIG_fail;
33853 }
33854 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33855 return resultobj;
33856 fail:
33857 return NULL;
33858 }
33859
33860
33861 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33862 PyObject *resultobj = 0;
33863 wxWindow *arg1 = (wxWindow *) 0 ;
33864 wxPoint *arg2 = 0 ;
33865 wxPoint result;
33866 void *argp1 = 0 ;
33867 int res1 = 0 ;
33868 wxPoint temp2 ;
33869 PyObject * obj0 = 0 ;
33870 PyObject * obj1 = 0 ;
33871 char * kwnames[] = {
33872 (char *) "self",(char *) "pt", NULL
33873 };
33874
33875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33877 if (!SWIG_IsOK(res1)) {
33878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33879 }
33880 arg1 = reinterpret_cast< wxWindow * >(argp1);
33881 {
33882 arg2 = &temp2;
33883 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33884 }
33885 {
33886 PyThreadState* __tstate = wxPyBeginAllowThreads();
33887 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33888 wxPyEndAllowThreads(__tstate);
33889 if (PyErr_Occurred()) SWIG_fail;
33890 }
33891 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33892 return resultobj;
33893 fail:
33894 return NULL;
33895 }
33896
33897
33898 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33899 PyObject *resultobj = 0;
33900 wxWindow *arg1 = (wxWindow *) 0 ;
33901 wxSize *arg2 = 0 ;
33902 wxSize result;
33903 void *argp1 = 0 ;
33904 int res1 = 0 ;
33905 wxSize temp2 ;
33906 PyObject * obj0 = 0 ;
33907 PyObject * obj1 = 0 ;
33908 char * kwnames[] = {
33909 (char *) "self",(char *) "sz", NULL
33910 };
33911
33912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33914 if (!SWIG_IsOK(res1)) {
33915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33916 }
33917 arg1 = reinterpret_cast< wxWindow * >(argp1);
33918 {
33919 arg2 = &temp2;
33920 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33921 }
33922 {
33923 PyThreadState* __tstate = wxPyBeginAllowThreads();
33924 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33925 wxPyEndAllowThreads(__tstate);
33926 if (PyErr_Occurred()) SWIG_fail;
33927 }
33928 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33929 return resultobj;
33930 fail:
33931 return NULL;
33932 }
33933
33934
33935 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33936 PyObject *resultobj = 0;
33937 wxWindow *arg1 = (wxWindow *) 0 ;
33938 int arg2 ;
33939 int arg3 ;
33940 void *argp1 = 0 ;
33941 int res1 = 0 ;
33942 int val2 ;
33943 int ecode2 = 0 ;
33944 int val3 ;
33945 int ecode3 = 0 ;
33946 PyObject * obj0 = 0 ;
33947 PyObject * obj1 = 0 ;
33948 PyObject * obj2 = 0 ;
33949 char * kwnames[] = {
33950 (char *) "self",(char *) "x",(char *) "y", NULL
33951 };
33952
33953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33955 if (!SWIG_IsOK(res1)) {
33956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
33957 }
33958 arg1 = reinterpret_cast< wxWindow * >(argp1);
33959 ecode2 = SWIG_AsVal_int(obj1, &val2);
33960 if (!SWIG_IsOK(ecode2)) {
33961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
33962 }
33963 arg2 = static_cast< int >(val2);
33964 ecode3 = SWIG_AsVal_int(obj2, &val3);
33965 if (!SWIG_IsOK(ecode3)) {
33966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
33967 }
33968 arg3 = static_cast< int >(val3);
33969 {
33970 PyThreadState* __tstate = wxPyBeginAllowThreads();
33971 (arg1)->WarpPointer(arg2,arg3);
33972 wxPyEndAllowThreads(__tstate);
33973 if (PyErr_Occurred()) SWIG_fail;
33974 }
33975 resultobj = SWIG_Py_Void();
33976 return resultobj;
33977 fail:
33978 return NULL;
33979 }
33980
33981
33982 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33983 PyObject *resultobj = 0;
33984 wxWindow *arg1 = (wxWindow *) 0 ;
33985 void *argp1 = 0 ;
33986 int res1 = 0 ;
33987 PyObject *swig_obj[1] ;
33988
33989 if (!args) SWIG_fail;
33990 swig_obj[0] = args;
33991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33992 if (!SWIG_IsOK(res1)) {
33993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33994 }
33995 arg1 = reinterpret_cast< wxWindow * >(argp1);
33996 {
33997 PyThreadState* __tstate = wxPyBeginAllowThreads();
33998 (arg1)->CaptureMouse();
33999 wxPyEndAllowThreads(__tstate);
34000 if (PyErr_Occurred()) SWIG_fail;
34001 }
34002 resultobj = SWIG_Py_Void();
34003 return resultobj;
34004 fail:
34005 return NULL;
34006 }
34007
34008
34009 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34010 PyObject *resultobj = 0;
34011 wxWindow *arg1 = (wxWindow *) 0 ;
34012 void *argp1 = 0 ;
34013 int res1 = 0 ;
34014 PyObject *swig_obj[1] ;
34015
34016 if (!args) SWIG_fail;
34017 swig_obj[0] = args;
34018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34019 if (!SWIG_IsOK(res1)) {
34020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34021 }
34022 arg1 = reinterpret_cast< wxWindow * >(argp1);
34023 {
34024 PyThreadState* __tstate = wxPyBeginAllowThreads();
34025 (arg1)->ReleaseMouse();
34026 wxPyEndAllowThreads(__tstate);
34027 if (PyErr_Occurred()) SWIG_fail;
34028 }
34029 resultobj = SWIG_Py_Void();
34030 return resultobj;
34031 fail:
34032 return NULL;
34033 }
34034
34035
34036 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34037 PyObject *resultobj = 0;
34038 wxWindow *result = 0 ;
34039
34040 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34041 {
34042 if (!wxPyCheckForApp()) SWIG_fail;
34043 PyThreadState* __tstate = wxPyBeginAllowThreads();
34044 result = (wxWindow *)wxWindow::GetCapture();
34045 wxPyEndAllowThreads(__tstate);
34046 if (PyErr_Occurred()) SWIG_fail;
34047 }
34048 {
34049 resultobj = wxPyMake_wxObject(result, 0);
34050 }
34051 return resultobj;
34052 fail:
34053 return NULL;
34054 }
34055
34056
34057 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34058 PyObject *resultobj = 0;
34059 wxWindow *arg1 = (wxWindow *) 0 ;
34060 bool result;
34061 void *argp1 = 0 ;
34062 int res1 = 0 ;
34063 PyObject *swig_obj[1] ;
34064
34065 if (!args) SWIG_fail;
34066 swig_obj[0] = args;
34067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34068 if (!SWIG_IsOK(res1)) {
34069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34070 }
34071 arg1 = reinterpret_cast< wxWindow * >(argp1);
34072 {
34073 PyThreadState* __tstate = wxPyBeginAllowThreads();
34074 result = (bool)((wxWindow const *)arg1)->HasCapture();
34075 wxPyEndAllowThreads(__tstate);
34076 if (PyErr_Occurred()) SWIG_fail;
34077 }
34078 {
34079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34080 }
34081 return resultobj;
34082 fail:
34083 return NULL;
34084 }
34085
34086
34087 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34088 PyObject *resultobj = 0;
34089 wxWindow *arg1 = (wxWindow *) 0 ;
34090 bool arg2 = (bool) true ;
34091 wxRect *arg3 = (wxRect *) NULL ;
34092 void *argp1 = 0 ;
34093 int res1 = 0 ;
34094 bool val2 ;
34095 int ecode2 = 0 ;
34096 void *argp3 = 0 ;
34097 int res3 = 0 ;
34098 PyObject * obj0 = 0 ;
34099 PyObject * obj1 = 0 ;
34100 PyObject * obj2 = 0 ;
34101 char * kwnames[] = {
34102 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34103 };
34104
34105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34107 if (!SWIG_IsOK(res1)) {
34108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34109 }
34110 arg1 = reinterpret_cast< wxWindow * >(argp1);
34111 if (obj1) {
34112 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34113 if (!SWIG_IsOK(ecode2)) {
34114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34115 }
34116 arg2 = static_cast< bool >(val2);
34117 }
34118 if (obj2) {
34119 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34120 if (!SWIG_IsOK(res3)) {
34121 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34122 }
34123 arg3 = reinterpret_cast< wxRect * >(argp3);
34124 }
34125 {
34126 PyThreadState* __tstate = wxPyBeginAllowThreads();
34127 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34128 wxPyEndAllowThreads(__tstate);
34129 if (PyErr_Occurred()) SWIG_fail;
34130 }
34131 resultobj = SWIG_Py_Void();
34132 return resultobj;
34133 fail:
34134 return NULL;
34135 }
34136
34137
34138 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34139 PyObject *resultobj = 0;
34140 wxWindow *arg1 = (wxWindow *) 0 ;
34141 wxRect *arg2 = 0 ;
34142 bool arg3 = (bool) true ;
34143 void *argp1 = 0 ;
34144 int res1 = 0 ;
34145 wxRect temp2 ;
34146 bool val3 ;
34147 int ecode3 = 0 ;
34148 PyObject * obj0 = 0 ;
34149 PyObject * obj1 = 0 ;
34150 PyObject * obj2 = 0 ;
34151 char * kwnames[] = {
34152 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34153 };
34154
34155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34157 if (!SWIG_IsOK(res1)) {
34158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34159 }
34160 arg1 = reinterpret_cast< wxWindow * >(argp1);
34161 {
34162 arg2 = &temp2;
34163 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34164 }
34165 if (obj2) {
34166 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34167 if (!SWIG_IsOK(ecode3)) {
34168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34169 }
34170 arg3 = static_cast< bool >(val3);
34171 }
34172 {
34173 PyThreadState* __tstate = wxPyBeginAllowThreads();
34174 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34175 wxPyEndAllowThreads(__tstate);
34176 if (PyErr_Occurred()) SWIG_fail;
34177 }
34178 resultobj = SWIG_Py_Void();
34179 return resultobj;
34180 fail:
34181 return NULL;
34182 }
34183
34184
34185 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34186 PyObject *resultobj = 0;
34187 wxWindow *arg1 = (wxWindow *) 0 ;
34188 void *argp1 = 0 ;
34189 int res1 = 0 ;
34190 PyObject *swig_obj[1] ;
34191
34192 if (!args) SWIG_fail;
34193 swig_obj[0] = args;
34194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34195 if (!SWIG_IsOK(res1)) {
34196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34197 }
34198 arg1 = reinterpret_cast< wxWindow * >(argp1);
34199 {
34200 PyThreadState* __tstate = wxPyBeginAllowThreads();
34201 (arg1)->Update();
34202 wxPyEndAllowThreads(__tstate);
34203 if (PyErr_Occurred()) SWIG_fail;
34204 }
34205 resultobj = SWIG_Py_Void();
34206 return resultobj;
34207 fail:
34208 return NULL;
34209 }
34210
34211
34212 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34213 PyObject *resultobj = 0;
34214 wxWindow *arg1 = (wxWindow *) 0 ;
34215 void *argp1 = 0 ;
34216 int res1 = 0 ;
34217 PyObject *swig_obj[1] ;
34218
34219 if (!args) SWIG_fail;
34220 swig_obj[0] = args;
34221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34222 if (!SWIG_IsOK(res1)) {
34223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34224 }
34225 arg1 = reinterpret_cast< wxWindow * >(argp1);
34226 {
34227 PyThreadState* __tstate = wxPyBeginAllowThreads();
34228 (arg1)->ClearBackground();
34229 wxPyEndAllowThreads(__tstate);
34230 if (PyErr_Occurred()) SWIG_fail;
34231 }
34232 resultobj = SWIG_Py_Void();
34233 return resultobj;
34234 fail:
34235 return NULL;
34236 }
34237
34238
34239 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34240 PyObject *resultobj = 0;
34241 wxWindow *arg1 = (wxWindow *) 0 ;
34242 void *argp1 = 0 ;
34243 int res1 = 0 ;
34244 PyObject *swig_obj[1] ;
34245
34246 if (!args) SWIG_fail;
34247 swig_obj[0] = args;
34248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34249 if (!SWIG_IsOK(res1)) {
34250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34251 }
34252 arg1 = reinterpret_cast< wxWindow * >(argp1);
34253 {
34254 PyThreadState* __tstate = wxPyBeginAllowThreads();
34255 (arg1)->Freeze();
34256 wxPyEndAllowThreads(__tstate);
34257 if (PyErr_Occurred()) SWIG_fail;
34258 }
34259 resultobj = SWIG_Py_Void();
34260 return resultobj;
34261 fail:
34262 return NULL;
34263 }
34264
34265
34266 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34267 PyObject *resultobj = 0;
34268 wxWindow *arg1 = (wxWindow *) 0 ;
34269 void *argp1 = 0 ;
34270 int res1 = 0 ;
34271 PyObject *swig_obj[1] ;
34272
34273 if (!args) SWIG_fail;
34274 swig_obj[0] = args;
34275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34276 if (!SWIG_IsOK(res1)) {
34277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34278 }
34279 arg1 = reinterpret_cast< wxWindow * >(argp1);
34280 {
34281 PyThreadState* __tstate = wxPyBeginAllowThreads();
34282 (arg1)->Thaw();
34283 wxPyEndAllowThreads(__tstate);
34284 if (PyErr_Occurred()) SWIG_fail;
34285 }
34286 resultobj = SWIG_Py_Void();
34287 return resultobj;
34288 fail:
34289 return NULL;
34290 }
34291
34292
34293 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34294 PyObject *resultobj = 0;
34295 wxWindow *arg1 = (wxWindow *) 0 ;
34296 wxDC *arg2 = 0 ;
34297 void *argp1 = 0 ;
34298 int res1 = 0 ;
34299 void *argp2 = 0 ;
34300 int res2 = 0 ;
34301 PyObject * obj0 = 0 ;
34302 PyObject * obj1 = 0 ;
34303 char * kwnames[] = {
34304 (char *) "self",(char *) "dc", NULL
34305 };
34306
34307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34309 if (!SWIG_IsOK(res1)) {
34310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34311 }
34312 arg1 = reinterpret_cast< wxWindow * >(argp1);
34313 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34314 if (!SWIG_IsOK(res2)) {
34315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34316 }
34317 if (!argp2) {
34318 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34319 }
34320 arg2 = reinterpret_cast< wxDC * >(argp2);
34321 {
34322 PyThreadState* __tstate = wxPyBeginAllowThreads();
34323 (arg1)->PrepareDC(*arg2);
34324 wxPyEndAllowThreads(__tstate);
34325 if (PyErr_Occurred()) SWIG_fail;
34326 }
34327 resultobj = SWIG_Py_Void();
34328 return resultobj;
34329 fail:
34330 return NULL;
34331 }
34332
34333
34334 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34335 PyObject *resultobj = 0;
34336 wxWindow *arg1 = (wxWindow *) 0 ;
34337 wxRegion *result = 0 ;
34338 void *argp1 = 0 ;
34339 int res1 = 0 ;
34340 PyObject *swig_obj[1] ;
34341
34342 if (!args) SWIG_fail;
34343 swig_obj[0] = args;
34344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34345 if (!SWIG_IsOK(res1)) {
34346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34347 }
34348 arg1 = reinterpret_cast< wxWindow * >(argp1);
34349 {
34350 PyThreadState* __tstate = wxPyBeginAllowThreads();
34351 {
34352 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34353 result = (wxRegion *) &_result_ref;
34354 }
34355 wxPyEndAllowThreads(__tstate);
34356 if (PyErr_Occurred()) SWIG_fail;
34357 }
34358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34359 return resultobj;
34360 fail:
34361 return NULL;
34362 }
34363
34364
34365 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34366 PyObject *resultobj = 0;
34367 wxWindow *arg1 = (wxWindow *) 0 ;
34368 wxRect result;
34369 void *argp1 = 0 ;
34370 int res1 = 0 ;
34371 PyObject *swig_obj[1] ;
34372
34373 if (!args) SWIG_fail;
34374 swig_obj[0] = args;
34375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34376 if (!SWIG_IsOK(res1)) {
34377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34378 }
34379 arg1 = reinterpret_cast< wxWindow * >(argp1);
34380 {
34381 PyThreadState* __tstate = wxPyBeginAllowThreads();
34382 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34383 wxPyEndAllowThreads(__tstate);
34384 if (PyErr_Occurred()) SWIG_fail;
34385 }
34386 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34387 return resultobj;
34388 fail:
34389 return NULL;
34390 }
34391
34392
34393 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34394 PyObject *resultobj = 0;
34395 wxWindow *arg1 = (wxWindow *) 0 ;
34396 int arg2 ;
34397 int arg3 ;
34398 int arg4 = (int) 1 ;
34399 int arg5 = (int) 1 ;
34400 bool result;
34401 void *argp1 = 0 ;
34402 int res1 = 0 ;
34403 int val2 ;
34404 int ecode2 = 0 ;
34405 int val3 ;
34406 int ecode3 = 0 ;
34407 int val4 ;
34408 int ecode4 = 0 ;
34409 int val5 ;
34410 int ecode5 = 0 ;
34411 PyObject * obj0 = 0 ;
34412 PyObject * obj1 = 0 ;
34413 PyObject * obj2 = 0 ;
34414 PyObject * obj3 = 0 ;
34415 PyObject * obj4 = 0 ;
34416 char * kwnames[] = {
34417 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34418 };
34419
34420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34422 if (!SWIG_IsOK(res1)) {
34423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34424 }
34425 arg1 = reinterpret_cast< wxWindow * >(argp1);
34426 ecode2 = SWIG_AsVal_int(obj1, &val2);
34427 if (!SWIG_IsOK(ecode2)) {
34428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34429 }
34430 arg2 = static_cast< int >(val2);
34431 ecode3 = SWIG_AsVal_int(obj2, &val3);
34432 if (!SWIG_IsOK(ecode3)) {
34433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34434 }
34435 arg3 = static_cast< int >(val3);
34436 if (obj3) {
34437 ecode4 = SWIG_AsVal_int(obj3, &val4);
34438 if (!SWIG_IsOK(ecode4)) {
34439 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34440 }
34441 arg4 = static_cast< int >(val4);
34442 }
34443 if (obj4) {
34444 ecode5 = SWIG_AsVal_int(obj4, &val5);
34445 if (!SWIG_IsOK(ecode5)) {
34446 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34447 }
34448 arg5 = static_cast< int >(val5);
34449 }
34450 {
34451 PyThreadState* __tstate = wxPyBeginAllowThreads();
34452 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34453 wxPyEndAllowThreads(__tstate);
34454 if (PyErr_Occurred()) SWIG_fail;
34455 }
34456 {
34457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34458 }
34459 return resultobj;
34460 fail:
34461 return NULL;
34462 }
34463
34464
34465 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34466 PyObject *resultobj = 0;
34467 wxWindow *arg1 = (wxWindow *) 0 ;
34468 wxPoint *arg2 = 0 ;
34469 bool result;
34470 void *argp1 = 0 ;
34471 int res1 = 0 ;
34472 wxPoint temp2 ;
34473 PyObject * obj0 = 0 ;
34474 PyObject * obj1 = 0 ;
34475 char * kwnames[] = {
34476 (char *) "self",(char *) "pt", NULL
34477 };
34478
34479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34481 if (!SWIG_IsOK(res1)) {
34482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34483 }
34484 arg1 = reinterpret_cast< wxWindow * >(argp1);
34485 {
34486 arg2 = &temp2;
34487 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34488 }
34489 {
34490 PyThreadState* __tstate = wxPyBeginAllowThreads();
34491 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34492 wxPyEndAllowThreads(__tstate);
34493 if (PyErr_Occurred()) SWIG_fail;
34494 }
34495 {
34496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34497 }
34498 return resultobj;
34499 fail:
34500 return NULL;
34501 }
34502
34503
34504 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34505 PyObject *resultobj = 0;
34506 wxWindow *arg1 = (wxWindow *) 0 ;
34507 wxRect *arg2 = 0 ;
34508 bool result;
34509 void *argp1 = 0 ;
34510 int res1 = 0 ;
34511 wxRect temp2 ;
34512 PyObject * obj0 = 0 ;
34513 PyObject * obj1 = 0 ;
34514 char * kwnames[] = {
34515 (char *) "self",(char *) "rect", NULL
34516 };
34517
34518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34520 if (!SWIG_IsOK(res1)) {
34521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34522 }
34523 arg1 = reinterpret_cast< wxWindow * >(argp1);
34524 {
34525 arg2 = &temp2;
34526 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34527 }
34528 {
34529 PyThreadState* __tstate = wxPyBeginAllowThreads();
34530 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34531 wxPyEndAllowThreads(__tstate);
34532 if (PyErr_Occurred()) SWIG_fail;
34533 }
34534 {
34535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34536 }
34537 return resultobj;
34538 fail:
34539 return NULL;
34540 }
34541
34542
34543 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34544 PyObject *resultobj = 0;
34545 wxWindow *arg1 = (wxWindow *) 0 ;
34546 SwigValueWrapper<wxVisualAttributes > result;
34547 void *argp1 = 0 ;
34548 int res1 = 0 ;
34549 PyObject *swig_obj[1] ;
34550
34551 if (!args) SWIG_fail;
34552 swig_obj[0] = args;
34553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34554 if (!SWIG_IsOK(res1)) {
34555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34556 }
34557 arg1 = reinterpret_cast< wxWindow * >(argp1);
34558 {
34559 PyThreadState* __tstate = wxPyBeginAllowThreads();
34560 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34561 wxPyEndAllowThreads(__tstate);
34562 if (PyErr_Occurred()) SWIG_fail;
34563 }
34564 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34565 return resultobj;
34566 fail:
34567 return NULL;
34568 }
34569
34570
34571 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34572 PyObject *resultobj = 0;
34573 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34574 SwigValueWrapper<wxVisualAttributes > result;
34575 int val1 ;
34576 int ecode1 = 0 ;
34577 PyObject * obj0 = 0 ;
34578 char * kwnames[] = {
34579 (char *) "variant", NULL
34580 };
34581
34582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34583 if (obj0) {
34584 ecode1 = SWIG_AsVal_int(obj0, &val1);
34585 if (!SWIG_IsOK(ecode1)) {
34586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34587 }
34588 arg1 = static_cast< wxWindowVariant >(val1);
34589 }
34590 {
34591 if (!wxPyCheckForApp()) SWIG_fail;
34592 PyThreadState* __tstate = wxPyBeginAllowThreads();
34593 result = wxWindow::GetClassDefaultAttributes(arg1);
34594 wxPyEndAllowThreads(__tstate);
34595 if (PyErr_Occurred()) SWIG_fail;
34596 }
34597 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34598 return resultobj;
34599 fail:
34600 return NULL;
34601 }
34602
34603
34604 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34605 PyObject *resultobj = 0;
34606 wxWindow *arg1 = (wxWindow *) 0 ;
34607 wxColour *arg2 = 0 ;
34608 bool result;
34609 void *argp1 = 0 ;
34610 int res1 = 0 ;
34611 wxColour temp2 ;
34612 PyObject * obj0 = 0 ;
34613 PyObject * obj1 = 0 ;
34614 char * kwnames[] = {
34615 (char *) "self",(char *) "colour", NULL
34616 };
34617
34618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34620 if (!SWIG_IsOK(res1)) {
34621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34622 }
34623 arg1 = reinterpret_cast< wxWindow * >(argp1);
34624 {
34625 arg2 = &temp2;
34626 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34627 }
34628 {
34629 PyThreadState* __tstate = wxPyBeginAllowThreads();
34630 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34631 wxPyEndAllowThreads(__tstate);
34632 if (PyErr_Occurred()) SWIG_fail;
34633 }
34634 {
34635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34636 }
34637 return resultobj;
34638 fail:
34639 return NULL;
34640 }
34641
34642
34643 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34644 PyObject *resultobj = 0;
34645 wxWindow *arg1 = (wxWindow *) 0 ;
34646 wxColour *arg2 = 0 ;
34647 void *argp1 = 0 ;
34648 int res1 = 0 ;
34649 wxColour temp2 ;
34650 PyObject * obj0 = 0 ;
34651 PyObject * obj1 = 0 ;
34652 char * kwnames[] = {
34653 (char *) "self",(char *) "colour", NULL
34654 };
34655
34656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34658 if (!SWIG_IsOK(res1)) {
34659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34660 }
34661 arg1 = reinterpret_cast< wxWindow * >(argp1);
34662 {
34663 arg2 = &temp2;
34664 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34665 }
34666 {
34667 PyThreadState* __tstate = wxPyBeginAllowThreads();
34668 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34669 wxPyEndAllowThreads(__tstate);
34670 if (PyErr_Occurred()) SWIG_fail;
34671 }
34672 resultobj = SWIG_Py_Void();
34673 return resultobj;
34674 fail:
34675 return NULL;
34676 }
34677
34678
34679 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34680 PyObject *resultobj = 0;
34681 wxWindow *arg1 = (wxWindow *) 0 ;
34682 wxColour *arg2 = 0 ;
34683 bool result;
34684 void *argp1 = 0 ;
34685 int res1 = 0 ;
34686 wxColour temp2 ;
34687 PyObject * obj0 = 0 ;
34688 PyObject * obj1 = 0 ;
34689 char * kwnames[] = {
34690 (char *) "self",(char *) "colour", NULL
34691 };
34692
34693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34695 if (!SWIG_IsOK(res1)) {
34696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34697 }
34698 arg1 = reinterpret_cast< wxWindow * >(argp1);
34699 {
34700 arg2 = &temp2;
34701 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34702 }
34703 {
34704 PyThreadState* __tstate = wxPyBeginAllowThreads();
34705 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34706 wxPyEndAllowThreads(__tstate);
34707 if (PyErr_Occurred()) SWIG_fail;
34708 }
34709 {
34710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34711 }
34712 return resultobj;
34713 fail:
34714 return NULL;
34715 }
34716
34717
34718 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34719 PyObject *resultobj = 0;
34720 wxWindow *arg1 = (wxWindow *) 0 ;
34721 wxColour *arg2 = 0 ;
34722 void *argp1 = 0 ;
34723 int res1 = 0 ;
34724 wxColour temp2 ;
34725 PyObject * obj0 = 0 ;
34726 PyObject * obj1 = 0 ;
34727 char * kwnames[] = {
34728 (char *) "self",(char *) "colour", NULL
34729 };
34730
34731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34733 if (!SWIG_IsOK(res1)) {
34734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34735 }
34736 arg1 = reinterpret_cast< wxWindow * >(argp1);
34737 {
34738 arg2 = &temp2;
34739 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34740 }
34741 {
34742 PyThreadState* __tstate = wxPyBeginAllowThreads();
34743 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34744 wxPyEndAllowThreads(__tstate);
34745 if (PyErr_Occurred()) SWIG_fail;
34746 }
34747 resultobj = SWIG_Py_Void();
34748 return resultobj;
34749 fail:
34750 return NULL;
34751 }
34752
34753
34754 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34755 PyObject *resultobj = 0;
34756 wxWindow *arg1 = (wxWindow *) 0 ;
34757 wxColour result;
34758 void *argp1 = 0 ;
34759 int res1 = 0 ;
34760 PyObject *swig_obj[1] ;
34761
34762 if (!args) SWIG_fail;
34763 swig_obj[0] = args;
34764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34765 if (!SWIG_IsOK(res1)) {
34766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34767 }
34768 arg1 = reinterpret_cast< wxWindow * >(argp1);
34769 {
34770 PyThreadState* __tstate = wxPyBeginAllowThreads();
34771 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34772 wxPyEndAllowThreads(__tstate);
34773 if (PyErr_Occurred()) SWIG_fail;
34774 }
34775 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34776 return resultobj;
34777 fail:
34778 return NULL;
34779 }
34780
34781
34782 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34783 PyObject *resultobj = 0;
34784 wxWindow *arg1 = (wxWindow *) 0 ;
34785 wxColour result;
34786 void *argp1 = 0 ;
34787 int res1 = 0 ;
34788 PyObject *swig_obj[1] ;
34789
34790 if (!args) SWIG_fail;
34791 swig_obj[0] = args;
34792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34793 if (!SWIG_IsOK(res1)) {
34794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34795 }
34796 arg1 = reinterpret_cast< wxWindow * >(argp1);
34797 {
34798 PyThreadState* __tstate = wxPyBeginAllowThreads();
34799 result = ((wxWindow const *)arg1)->GetForegroundColour();
34800 wxPyEndAllowThreads(__tstate);
34801 if (PyErr_Occurred()) SWIG_fail;
34802 }
34803 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34804 return resultobj;
34805 fail:
34806 return NULL;
34807 }
34808
34809
34810 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34811 PyObject *resultobj = 0;
34812 wxWindow *arg1 = (wxWindow *) 0 ;
34813 bool result;
34814 void *argp1 = 0 ;
34815 int res1 = 0 ;
34816 PyObject *swig_obj[1] ;
34817
34818 if (!args) SWIG_fail;
34819 swig_obj[0] = args;
34820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34821 if (!SWIG_IsOK(res1)) {
34822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34823 }
34824 arg1 = reinterpret_cast< wxWindow * >(argp1);
34825 {
34826 PyThreadState* __tstate = wxPyBeginAllowThreads();
34827 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34828 wxPyEndAllowThreads(__tstate);
34829 if (PyErr_Occurred()) SWIG_fail;
34830 }
34831 {
34832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34833 }
34834 return resultobj;
34835 fail:
34836 return NULL;
34837 }
34838
34839
34840 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34841 PyObject *resultobj = 0;
34842 wxWindow *arg1 = (wxWindow *) 0 ;
34843 bool result;
34844 void *argp1 = 0 ;
34845 int res1 = 0 ;
34846 PyObject *swig_obj[1] ;
34847
34848 if (!args) SWIG_fail;
34849 swig_obj[0] = args;
34850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34851 if (!SWIG_IsOK(res1)) {
34852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34853 }
34854 arg1 = reinterpret_cast< wxWindow * >(argp1);
34855 {
34856 PyThreadState* __tstate = wxPyBeginAllowThreads();
34857 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34858 wxPyEndAllowThreads(__tstate);
34859 if (PyErr_Occurred()) SWIG_fail;
34860 }
34861 {
34862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34863 }
34864 return resultobj;
34865 fail:
34866 return NULL;
34867 }
34868
34869
34870 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34871 PyObject *resultobj = 0;
34872 wxWindow *arg1 = (wxWindow *) 0 ;
34873 wxBackgroundStyle arg2 ;
34874 bool result;
34875 void *argp1 = 0 ;
34876 int res1 = 0 ;
34877 int val2 ;
34878 int ecode2 = 0 ;
34879 PyObject * obj0 = 0 ;
34880 PyObject * obj1 = 0 ;
34881 char * kwnames[] = {
34882 (char *) "self",(char *) "style", NULL
34883 };
34884
34885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34887 if (!SWIG_IsOK(res1)) {
34888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34889 }
34890 arg1 = reinterpret_cast< wxWindow * >(argp1);
34891 ecode2 = SWIG_AsVal_int(obj1, &val2);
34892 if (!SWIG_IsOK(ecode2)) {
34893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34894 }
34895 arg2 = static_cast< wxBackgroundStyle >(val2);
34896 {
34897 PyThreadState* __tstate = wxPyBeginAllowThreads();
34898 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34899 wxPyEndAllowThreads(__tstate);
34900 if (PyErr_Occurred()) SWIG_fail;
34901 }
34902 {
34903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34904 }
34905 return resultobj;
34906 fail:
34907 return NULL;
34908 }
34909
34910
34911 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34912 PyObject *resultobj = 0;
34913 wxWindow *arg1 = (wxWindow *) 0 ;
34914 wxBackgroundStyle result;
34915 void *argp1 = 0 ;
34916 int res1 = 0 ;
34917 PyObject *swig_obj[1] ;
34918
34919 if (!args) SWIG_fail;
34920 swig_obj[0] = args;
34921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34922 if (!SWIG_IsOK(res1)) {
34923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34924 }
34925 arg1 = reinterpret_cast< wxWindow * >(argp1);
34926 {
34927 PyThreadState* __tstate = wxPyBeginAllowThreads();
34928 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34929 wxPyEndAllowThreads(__tstate);
34930 if (PyErr_Occurred()) SWIG_fail;
34931 }
34932 resultobj = SWIG_From_int(static_cast< int >(result));
34933 return resultobj;
34934 fail:
34935 return NULL;
34936 }
34937
34938
34939 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34940 PyObject *resultobj = 0;
34941 wxWindow *arg1 = (wxWindow *) 0 ;
34942 bool result;
34943 void *argp1 = 0 ;
34944 int res1 = 0 ;
34945 PyObject *swig_obj[1] ;
34946
34947 if (!args) SWIG_fail;
34948 swig_obj[0] = args;
34949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34950 if (!SWIG_IsOK(res1)) {
34951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34952 }
34953 arg1 = reinterpret_cast< wxWindow * >(argp1);
34954 {
34955 PyThreadState* __tstate = wxPyBeginAllowThreads();
34956 result = (bool)(arg1)->HasTransparentBackground();
34957 wxPyEndAllowThreads(__tstate);
34958 if (PyErr_Occurred()) SWIG_fail;
34959 }
34960 {
34961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34962 }
34963 return resultobj;
34964 fail:
34965 return NULL;
34966 }
34967
34968
34969 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34970 PyObject *resultobj = 0;
34971 wxWindow *arg1 = (wxWindow *) 0 ;
34972 wxCursor *arg2 = 0 ;
34973 bool result;
34974 void *argp1 = 0 ;
34975 int res1 = 0 ;
34976 void *argp2 = 0 ;
34977 int res2 = 0 ;
34978 PyObject * obj0 = 0 ;
34979 PyObject * obj1 = 0 ;
34980 char * kwnames[] = {
34981 (char *) "self",(char *) "cursor", NULL
34982 };
34983
34984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
34985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34986 if (!SWIG_IsOK(res1)) {
34987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
34988 }
34989 arg1 = reinterpret_cast< wxWindow * >(argp1);
34990 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
34991 if (!SWIG_IsOK(res2)) {
34992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34993 }
34994 if (!argp2) {
34995 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34996 }
34997 arg2 = reinterpret_cast< wxCursor * >(argp2);
34998 {
34999 PyThreadState* __tstate = wxPyBeginAllowThreads();
35000 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35001 wxPyEndAllowThreads(__tstate);
35002 if (PyErr_Occurred()) SWIG_fail;
35003 }
35004 {
35005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35006 }
35007 return resultobj;
35008 fail:
35009 return NULL;
35010 }
35011
35012
35013 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35014 PyObject *resultobj = 0;
35015 wxWindow *arg1 = (wxWindow *) 0 ;
35016 wxCursor result;
35017 void *argp1 = 0 ;
35018 int res1 = 0 ;
35019 PyObject *swig_obj[1] ;
35020
35021 if (!args) SWIG_fail;
35022 swig_obj[0] = args;
35023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35024 if (!SWIG_IsOK(res1)) {
35025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35026 }
35027 arg1 = reinterpret_cast< wxWindow * >(argp1);
35028 {
35029 PyThreadState* __tstate = wxPyBeginAllowThreads();
35030 result = (arg1)->GetCursor();
35031 wxPyEndAllowThreads(__tstate);
35032 if (PyErr_Occurred()) SWIG_fail;
35033 }
35034 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35035 return resultobj;
35036 fail:
35037 return NULL;
35038 }
35039
35040
35041 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35042 PyObject *resultobj = 0;
35043 wxWindow *arg1 = (wxWindow *) 0 ;
35044 wxFont *arg2 = 0 ;
35045 bool result;
35046 void *argp1 = 0 ;
35047 int res1 = 0 ;
35048 void *argp2 = 0 ;
35049 int res2 = 0 ;
35050 PyObject * obj0 = 0 ;
35051 PyObject * obj1 = 0 ;
35052 char * kwnames[] = {
35053 (char *) "self",(char *) "font", NULL
35054 };
35055
35056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35058 if (!SWIG_IsOK(res1)) {
35059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35060 }
35061 arg1 = reinterpret_cast< wxWindow * >(argp1);
35062 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35063 if (!SWIG_IsOK(res2)) {
35064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35065 }
35066 if (!argp2) {
35067 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35068 }
35069 arg2 = reinterpret_cast< wxFont * >(argp2);
35070 {
35071 PyThreadState* __tstate = wxPyBeginAllowThreads();
35072 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35073 wxPyEndAllowThreads(__tstate);
35074 if (PyErr_Occurred()) SWIG_fail;
35075 }
35076 {
35077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35078 }
35079 return resultobj;
35080 fail:
35081 return NULL;
35082 }
35083
35084
35085 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35086 PyObject *resultobj = 0;
35087 wxWindow *arg1 = (wxWindow *) 0 ;
35088 wxFont *arg2 = 0 ;
35089 void *argp1 = 0 ;
35090 int res1 = 0 ;
35091 void *argp2 = 0 ;
35092 int res2 = 0 ;
35093 PyObject * obj0 = 0 ;
35094 PyObject * obj1 = 0 ;
35095 char * kwnames[] = {
35096 (char *) "self",(char *) "font", NULL
35097 };
35098
35099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35101 if (!SWIG_IsOK(res1)) {
35102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35103 }
35104 arg1 = reinterpret_cast< wxWindow * >(argp1);
35105 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35106 if (!SWIG_IsOK(res2)) {
35107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35108 }
35109 if (!argp2) {
35110 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35111 }
35112 arg2 = reinterpret_cast< wxFont * >(argp2);
35113 {
35114 PyThreadState* __tstate = wxPyBeginAllowThreads();
35115 (arg1)->SetOwnFont((wxFont const &)*arg2);
35116 wxPyEndAllowThreads(__tstate);
35117 if (PyErr_Occurred()) SWIG_fail;
35118 }
35119 resultobj = SWIG_Py_Void();
35120 return resultobj;
35121 fail:
35122 return NULL;
35123 }
35124
35125
35126 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35127 PyObject *resultobj = 0;
35128 wxWindow *arg1 = (wxWindow *) 0 ;
35129 wxFont result;
35130 void *argp1 = 0 ;
35131 int res1 = 0 ;
35132 PyObject *swig_obj[1] ;
35133
35134 if (!args) SWIG_fail;
35135 swig_obj[0] = args;
35136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35137 if (!SWIG_IsOK(res1)) {
35138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35139 }
35140 arg1 = reinterpret_cast< wxWindow * >(argp1);
35141 {
35142 PyThreadState* __tstate = wxPyBeginAllowThreads();
35143 result = (arg1)->GetFont();
35144 wxPyEndAllowThreads(__tstate);
35145 if (PyErr_Occurred()) SWIG_fail;
35146 }
35147 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35148 return resultobj;
35149 fail:
35150 return NULL;
35151 }
35152
35153
35154 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35155 PyObject *resultobj = 0;
35156 wxWindow *arg1 = (wxWindow *) 0 ;
35157 wxCaret *arg2 = (wxCaret *) 0 ;
35158 void *argp1 = 0 ;
35159 int res1 = 0 ;
35160 int res2 = 0 ;
35161 PyObject * obj0 = 0 ;
35162 PyObject * obj1 = 0 ;
35163 char * kwnames[] = {
35164 (char *) "self",(char *) "caret", NULL
35165 };
35166
35167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35169 if (!SWIG_IsOK(res1)) {
35170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35171 }
35172 arg1 = reinterpret_cast< wxWindow * >(argp1);
35173 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35174 if (!SWIG_IsOK(res2)) {
35175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35176 }
35177 {
35178 PyThreadState* __tstate = wxPyBeginAllowThreads();
35179 (arg1)->SetCaret(arg2);
35180 wxPyEndAllowThreads(__tstate);
35181 if (PyErr_Occurred()) SWIG_fail;
35182 }
35183 resultobj = SWIG_Py_Void();
35184 return resultobj;
35185 fail:
35186 return NULL;
35187 }
35188
35189
35190 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35191 PyObject *resultobj = 0;
35192 wxWindow *arg1 = (wxWindow *) 0 ;
35193 wxCaret *result = 0 ;
35194 void *argp1 = 0 ;
35195 int res1 = 0 ;
35196 PyObject *swig_obj[1] ;
35197
35198 if (!args) SWIG_fail;
35199 swig_obj[0] = args;
35200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35201 if (!SWIG_IsOK(res1)) {
35202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35203 }
35204 arg1 = reinterpret_cast< wxWindow * >(argp1);
35205 {
35206 PyThreadState* __tstate = wxPyBeginAllowThreads();
35207 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35208 wxPyEndAllowThreads(__tstate);
35209 if (PyErr_Occurred()) SWIG_fail;
35210 }
35211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35212 return resultobj;
35213 fail:
35214 return NULL;
35215 }
35216
35217
35218 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35219 PyObject *resultobj = 0;
35220 wxWindow *arg1 = (wxWindow *) 0 ;
35221 int result;
35222 void *argp1 = 0 ;
35223 int res1 = 0 ;
35224 PyObject *swig_obj[1] ;
35225
35226 if (!args) SWIG_fail;
35227 swig_obj[0] = args;
35228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35229 if (!SWIG_IsOK(res1)) {
35230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35231 }
35232 arg1 = reinterpret_cast< wxWindow * >(argp1);
35233 {
35234 PyThreadState* __tstate = wxPyBeginAllowThreads();
35235 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35236 wxPyEndAllowThreads(__tstate);
35237 if (PyErr_Occurred()) SWIG_fail;
35238 }
35239 resultobj = SWIG_From_int(static_cast< int >(result));
35240 return resultobj;
35241 fail:
35242 return NULL;
35243 }
35244
35245
35246 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35247 PyObject *resultobj = 0;
35248 wxWindow *arg1 = (wxWindow *) 0 ;
35249 int result;
35250 void *argp1 = 0 ;
35251 int res1 = 0 ;
35252 PyObject *swig_obj[1] ;
35253
35254 if (!args) SWIG_fail;
35255 swig_obj[0] = args;
35256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35257 if (!SWIG_IsOK(res1)) {
35258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35259 }
35260 arg1 = reinterpret_cast< wxWindow * >(argp1);
35261 {
35262 PyThreadState* __tstate = wxPyBeginAllowThreads();
35263 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35264 wxPyEndAllowThreads(__tstate);
35265 if (PyErr_Occurred()) SWIG_fail;
35266 }
35267 resultobj = SWIG_From_int(static_cast< int >(result));
35268 return resultobj;
35269 fail:
35270 return NULL;
35271 }
35272
35273
35274 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35275 PyObject *resultobj = 0;
35276 wxWindow *arg1 = (wxWindow *) 0 ;
35277 wxString *arg2 = 0 ;
35278 int *arg3 = (int *) 0 ;
35279 int *arg4 = (int *) 0 ;
35280 void *argp1 = 0 ;
35281 int res1 = 0 ;
35282 bool temp2 = false ;
35283 int temp3 ;
35284 int res3 = SWIG_TMPOBJ ;
35285 int temp4 ;
35286 int res4 = SWIG_TMPOBJ ;
35287 PyObject * obj0 = 0 ;
35288 PyObject * obj1 = 0 ;
35289 char * kwnames[] = {
35290 (char *) "self",(char *) "string", NULL
35291 };
35292
35293 arg3 = &temp3;
35294 arg4 = &temp4;
35295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35297 if (!SWIG_IsOK(res1)) {
35298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35299 }
35300 arg1 = reinterpret_cast< wxWindow * >(argp1);
35301 {
35302 arg2 = wxString_in_helper(obj1);
35303 if (arg2 == NULL) SWIG_fail;
35304 temp2 = true;
35305 }
35306 {
35307 PyThreadState* __tstate = wxPyBeginAllowThreads();
35308 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35309 wxPyEndAllowThreads(__tstate);
35310 if (PyErr_Occurred()) SWIG_fail;
35311 }
35312 resultobj = SWIG_Py_Void();
35313 if (SWIG_IsTmpObj(res3)) {
35314 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35315 } else {
35316 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35317 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35318 }
35319 if (SWIG_IsTmpObj(res4)) {
35320 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35321 } else {
35322 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35324 }
35325 {
35326 if (temp2)
35327 delete arg2;
35328 }
35329 return resultobj;
35330 fail:
35331 {
35332 if (temp2)
35333 delete arg2;
35334 }
35335 return NULL;
35336 }
35337
35338
35339 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35340 PyObject *resultobj = 0;
35341 wxWindow *arg1 = (wxWindow *) 0 ;
35342 wxString *arg2 = 0 ;
35343 int *arg3 = (int *) 0 ;
35344 int *arg4 = (int *) 0 ;
35345 int *arg5 = (int *) 0 ;
35346 int *arg6 = (int *) 0 ;
35347 wxFont *arg7 = (wxFont *) NULL ;
35348 void *argp1 = 0 ;
35349 int res1 = 0 ;
35350 bool temp2 = false ;
35351 int temp3 ;
35352 int res3 = SWIG_TMPOBJ ;
35353 int temp4 ;
35354 int res4 = SWIG_TMPOBJ ;
35355 int temp5 ;
35356 int res5 = SWIG_TMPOBJ ;
35357 int temp6 ;
35358 int res6 = SWIG_TMPOBJ ;
35359 void *argp7 = 0 ;
35360 int res7 = 0 ;
35361 PyObject * obj0 = 0 ;
35362 PyObject * obj1 = 0 ;
35363 PyObject * obj2 = 0 ;
35364 char * kwnames[] = {
35365 (char *) "self",(char *) "string",(char *) "font", NULL
35366 };
35367
35368 arg3 = &temp3;
35369 arg4 = &temp4;
35370 arg5 = &temp5;
35371 arg6 = &temp6;
35372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35374 if (!SWIG_IsOK(res1)) {
35375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35376 }
35377 arg1 = reinterpret_cast< wxWindow * >(argp1);
35378 {
35379 arg2 = wxString_in_helper(obj1);
35380 if (arg2 == NULL) SWIG_fail;
35381 temp2 = true;
35382 }
35383 if (obj2) {
35384 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35385 if (!SWIG_IsOK(res7)) {
35386 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35387 }
35388 arg7 = reinterpret_cast< wxFont * >(argp7);
35389 }
35390 {
35391 PyThreadState* __tstate = wxPyBeginAllowThreads();
35392 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35393 wxPyEndAllowThreads(__tstate);
35394 if (PyErr_Occurred()) SWIG_fail;
35395 }
35396 resultobj = SWIG_Py_Void();
35397 if (SWIG_IsTmpObj(res3)) {
35398 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35399 } else {
35400 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35401 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35402 }
35403 if (SWIG_IsTmpObj(res4)) {
35404 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35405 } else {
35406 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35407 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35408 }
35409 if (SWIG_IsTmpObj(res5)) {
35410 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35411 } else {
35412 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35413 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35414 }
35415 if (SWIG_IsTmpObj(res6)) {
35416 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35417 } else {
35418 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35419 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35420 }
35421 {
35422 if (temp2)
35423 delete arg2;
35424 }
35425 return resultobj;
35426 fail:
35427 {
35428 if (temp2)
35429 delete arg2;
35430 }
35431 return NULL;
35432 }
35433
35434
35435 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35436 PyObject *resultobj = 0;
35437 wxWindow *arg1 = (wxWindow *) 0 ;
35438 int *arg2 = (int *) 0 ;
35439 int *arg3 = (int *) 0 ;
35440 void *argp1 = 0 ;
35441 int res1 = 0 ;
35442 int temp2 ;
35443 int res2 = 0 ;
35444 int temp3 ;
35445 int res3 = 0 ;
35446 PyObject * obj0 = 0 ;
35447 PyObject * obj1 = 0 ;
35448 PyObject * obj2 = 0 ;
35449 char * kwnames[] = {
35450 (char *) "self",(char *) "x",(char *) "y", NULL
35451 };
35452
35453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35455 if (!SWIG_IsOK(res1)) {
35456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35457 }
35458 arg1 = reinterpret_cast< wxWindow * >(argp1);
35459 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35460 int val;
35461 int ecode = SWIG_AsVal_int(obj1, &val);
35462 if (!SWIG_IsOK(ecode)) {
35463 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35464 }
35465 temp2 = static_cast< int >(val);
35466 arg2 = &temp2;
35467 res2 = SWIG_AddTmpMask(ecode);
35468 }
35469 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35470 int val;
35471 int ecode = SWIG_AsVal_int(obj2, &val);
35472 if (!SWIG_IsOK(ecode)) {
35473 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35474 }
35475 temp3 = static_cast< int >(val);
35476 arg3 = &temp3;
35477 res3 = SWIG_AddTmpMask(ecode);
35478 }
35479 {
35480 PyThreadState* __tstate = wxPyBeginAllowThreads();
35481 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35482 wxPyEndAllowThreads(__tstate);
35483 if (PyErr_Occurred()) SWIG_fail;
35484 }
35485 resultobj = SWIG_Py_Void();
35486 if (SWIG_IsTmpObj(res2)) {
35487 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35488 } else {
35489 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35490 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35491 }
35492 if (SWIG_IsTmpObj(res3)) {
35493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35494 } else {
35495 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35497 }
35498 return resultobj;
35499 fail:
35500 return NULL;
35501 }
35502
35503
35504 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35505 PyObject *resultobj = 0;
35506 wxWindow *arg1 = (wxWindow *) 0 ;
35507 int *arg2 = (int *) 0 ;
35508 int *arg3 = (int *) 0 ;
35509 void *argp1 = 0 ;
35510 int res1 = 0 ;
35511 int temp2 ;
35512 int res2 = 0 ;
35513 int temp3 ;
35514 int res3 = 0 ;
35515 PyObject * obj0 = 0 ;
35516 PyObject * obj1 = 0 ;
35517 PyObject * obj2 = 0 ;
35518 char * kwnames[] = {
35519 (char *) "self",(char *) "x",(char *) "y", NULL
35520 };
35521
35522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35524 if (!SWIG_IsOK(res1)) {
35525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35526 }
35527 arg1 = reinterpret_cast< wxWindow * >(argp1);
35528 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35529 int val;
35530 int ecode = SWIG_AsVal_int(obj1, &val);
35531 if (!SWIG_IsOK(ecode)) {
35532 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35533 }
35534 temp2 = static_cast< int >(val);
35535 arg2 = &temp2;
35536 res2 = SWIG_AddTmpMask(ecode);
35537 }
35538 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35539 int val;
35540 int ecode = SWIG_AsVal_int(obj2, &val);
35541 if (!SWIG_IsOK(ecode)) {
35542 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35543 }
35544 temp3 = static_cast< int >(val);
35545 arg3 = &temp3;
35546 res3 = SWIG_AddTmpMask(ecode);
35547 }
35548 {
35549 PyThreadState* __tstate = wxPyBeginAllowThreads();
35550 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35551 wxPyEndAllowThreads(__tstate);
35552 if (PyErr_Occurred()) SWIG_fail;
35553 }
35554 resultobj = SWIG_Py_Void();
35555 if (SWIG_IsTmpObj(res2)) {
35556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35557 } else {
35558 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35559 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35560 }
35561 if (SWIG_IsTmpObj(res3)) {
35562 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35563 } else {
35564 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35566 }
35567 return resultobj;
35568 fail:
35569 return NULL;
35570 }
35571
35572
35573 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35574 PyObject *resultobj = 0;
35575 wxWindow *arg1 = (wxWindow *) 0 ;
35576 wxPoint *arg2 = 0 ;
35577 wxPoint result;
35578 void *argp1 = 0 ;
35579 int res1 = 0 ;
35580 wxPoint temp2 ;
35581 PyObject * obj0 = 0 ;
35582 PyObject * obj1 = 0 ;
35583 char * kwnames[] = {
35584 (char *) "self",(char *) "pt", NULL
35585 };
35586
35587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35589 if (!SWIG_IsOK(res1)) {
35590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35591 }
35592 arg1 = reinterpret_cast< wxWindow * >(argp1);
35593 {
35594 arg2 = &temp2;
35595 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35596 }
35597 {
35598 PyThreadState* __tstate = wxPyBeginAllowThreads();
35599 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35600 wxPyEndAllowThreads(__tstate);
35601 if (PyErr_Occurred()) SWIG_fail;
35602 }
35603 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35604 return resultobj;
35605 fail:
35606 return NULL;
35607 }
35608
35609
35610 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35611 PyObject *resultobj = 0;
35612 wxWindow *arg1 = (wxWindow *) 0 ;
35613 wxPoint *arg2 = 0 ;
35614 wxPoint result;
35615 void *argp1 = 0 ;
35616 int res1 = 0 ;
35617 wxPoint temp2 ;
35618 PyObject * obj0 = 0 ;
35619 PyObject * obj1 = 0 ;
35620 char * kwnames[] = {
35621 (char *) "self",(char *) "pt", NULL
35622 };
35623
35624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35626 if (!SWIG_IsOK(res1)) {
35627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35628 }
35629 arg1 = reinterpret_cast< wxWindow * >(argp1);
35630 {
35631 arg2 = &temp2;
35632 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35633 }
35634 {
35635 PyThreadState* __tstate = wxPyBeginAllowThreads();
35636 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35637 wxPyEndAllowThreads(__tstate);
35638 if (PyErr_Occurred()) SWIG_fail;
35639 }
35640 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35641 return resultobj;
35642 fail:
35643 return NULL;
35644 }
35645
35646
35647 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35648 PyObject *resultobj = 0;
35649 wxWindow *arg1 = (wxWindow *) 0 ;
35650 int arg2 ;
35651 int arg3 ;
35652 wxHitTest result;
35653 void *argp1 = 0 ;
35654 int res1 = 0 ;
35655 int val2 ;
35656 int ecode2 = 0 ;
35657 int val3 ;
35658 int ecode3 = 0 ;
35659 PyObject * obj0 = 0 ;
35660 PyObject * obj1 = 0 ;
35661 PyObject * obj2 = 0 ;
35662 char * kwnames[] = {
35663 (char *) "self",(char *) "x",(char *) "y", NULL
35664 };
35665
35666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35668 if (!SWIG_IsOK(res1)) {
35669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35670 }
35671 arg1 = reinterpret_cast< wxWindow * >(argp1);
35672 ecode2 = SWIG_AsVal_int(obj1, &val2);
35673 if (!SWIG_IsOK(ecode2)) {
35674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35675 }
35676 arg2 = static_cast< int >(val2);
35677 ecode3 = SWIG_AsVal_int(obj2, &val3);
35678 if (!SWIG_IsOK(ecode3)) {
35679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35680 }
35681 arg3 = static_cast< int >(val3);
35682 {
35683 PyThreadState* __tstate = wxPyBeginAllowThreads();
35684 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35685 wxPyEndAllowThreads(__tstate);
35686 if (PyErr_Occurred()) SWIG_fail;
35687 }
35688 resultobj = SWIG_From_int(static_cast< int >(result));
35689 return resultobj;
35690 fail:
35691 return NULL;
35692 }
35693
35694
35695 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35696 PyObject *resultobj = 0;
35697 wxWindow *arg1 = (wxWindow *) 0 ;
35698 wxPoint *arg2 = 0 ;
35699 wxHitTest result;
35700 void *argp1 = 0 ;
35701 int res1 = 0 ;
35702 wxPoint temp2 ;
35703 PyObject * obj0 = 0 ;
35704 PyObject * obj1 = 0 ;
35705 char * kwnames[] = {
35706 (char *) "self",(char *) "pt", NULL
35707 };
35708
35709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35711 if (!SWIG_IsOK(res1)) {
35712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35713 }
35714 arg1 = reinterpret_cast< wxWindow * >(argp1);
35715 {
35716 arg2 = &temp2;
35717 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35718 }
35719 {
35720 PyThreadState* __tstate = wxPyBeginAllowThreads();
35721 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35722 wxPyEndAllowThreads(__tstate);
35723 if (PyErr_Occurred()) SWIG_fail;
35724 }
35725 resultobj = SWIG_From_int(static_cast< int >(result));
35726 return resultobj;
35727 fail:
35728 return NULL;
35729 }
35730
35731
35732 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35733 PyObject *resultobj = 0;
35734 wxWindow *arg1 = (wxWindow *) 0 ;
35735 long arg2 ;
35736 wxBorder result;
35737 void *argp1 = 0 ;
35738 int res1 = 0 ;
35739 long val2 ;
35740 int ecode2 = 0 ;
35741
35742 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35744 if (!SWIG_IsOK(res1)) {
35745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35746 }
35747 arg1 = reinterpret_cast< wxWindow * >(argp1);
35748 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35749 if (!SWIG_IsOK(ecode2)) {
35750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35751 }
35752 arg2 = static_cast< long >(val2);
35753 {
35754 PyThreadState* __tstate = wxPyBeginAllowThreads();
35755 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35756 wxPyEndAllowThreads(__tstate);
35757 if (PyErr_Occurred()) SWIG_fail;
35758 }
35759 resultobj = SWIG_From_int(static_cast< int >(result));
35760 return resultobj;
35761 fail:
35762 return NULL;
35763 }
35764
35765
35766 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35767 PyObject *resultobj = 0;
35768 wxWindow *arg1 = (wxWindow *) 0 ;
35769 wxBorder result;
35770 void *argp1 = 0 ;
35771 int res1 = 0 ;
35772
35773 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35775 if (!SWIG_IsOK(res1)) {
35776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35777 }
35778 arg1 = reinterpret_cast< wxWindow * >(argp1);
35779 {
35780 PyThreadState* __tstate = wxPyBeginAllowThreads();
35781 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35782 wxPyEndAllowThreads(__tstate);
35783 if (PyErr_Occurred()) SWIG_fail;
35784 }
35785 resultobj = SWIG_From_int(static_cast< int >(result));
35786 return resultobj;
35787 fail:
35788 return NULL;
35789 }
35790
35791
35792 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35793 int argc;
35794 PyObject *argv[3];
35795
35796 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35797 --argc;
35798 if (argc == 1) {
35799 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35800 }
35801 if (argc == 2) {
35802 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35803 }
35804
35805 fail:
35806 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35807 return NULL;
35808 }
35809
35810
35811 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35812 PyObject *resultobj = 0;
35813 wxWindow *arg1 = (wxWindow *) 0 ;
35814 long arg2 = (long) wxUPDATE_UI_NONE ;
35815 void *argp1 = 0 ;
35816 int res1 = 0 ;
35817 long val2 ;
35818 int ecode2 = 0 ;
35819 PyObject * obj0 = 0 ;
35820 PyObject * obj1 = 0 ;
35821 char * kwnames[] = {
35822 (char *) "self",(char *) "flags", NULL
35823 };
35824
35825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35827 if (!SWIG_IsOK(res1)) {
35828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35829 }
35830 arg1 = reinterpret_cast< wxWindow * >(argp1);
35831 if (obj1) {
35832 ecode2 = SWIG_AsVal_long(obj1, &val2);
35833 if (!SWIG_IsOK(ecode2)) {
35834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35835 }
35836 arg2 = static_cast< long >(val2);
35837 }
35838 {
35839 PyThreadState* __tstate = wxPyBeginAllowThreads();
35840 (arg1)->UpdateWindowUI(arg2);
35841 wxPyEndAllowThreads(__tstate);
35842 if (PyErr_Occurred()) SWIG_fail;
35843 }
35844 resultobj = SWIG_Py_Void();
35845 return resultobj;
35846 fail:
35847 return NULL;
35848 }
35849
35850
35851 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35852 PyObject *resultobj = 0;
35853 wxWindow *arg1 = (wxWindow *) 0 ;
35854 wxMenu *arg2 = (wxMenu *) 0 ;
35855 int arg3 = (int) -1 ;
35856 int arg4 = (int) -1 ;
35857 bool result;
35858 void *argp1 = 0 ;
35859 int res1 = 0 ;
35860 void *argp2 = 0 ;
35861 int res2 = 0 ;
35862 int val3 ;
35863 int ecode3 = 0 ;
35864 int val4 ;
35865 int ecode4 = 0 ;
35866 PyObject * obj0 = 0 ;
35867 PyObject * obj1 = 0 ;
35868 PyObject * obj2 = 0 ;
35869 PyObject * obj3 = 0 ;
35870 char * kwnames[] = {
35871 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35872 };
35873
35874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35876 if (!SWIG_IsOK(res1)) {
35877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35878 }
35879 arg1 = reinterpret_cast< wxWindow * >(argp1);
35880 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35881 if (!SWIG_IsOK(res2)) {
35882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35883 }
35884 arg2 = reinterpret_cast< wxMenu * >(argp2);
35885 if (obj2) {
35886 ecode3 = SWIG_AsVal_int(obj2, &val3);
35887 if (!SWIG_IsOK(ecode3)) {
35888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35889 }
35890 arg3 = static_cast< int >(val3);
35891 }
35892 if (obj3) {
35893 ecode4 = SWIG_AsVal_int(obj3, &val4);
35894 if (!SWIG_IsOK(ecode4)) {
35895 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35896 }
35897 arg4 = static_cast< int >(val4);
35898 }
35899 {
35900 PyThreadState* __tstate = wxPyBeginAllowThreads();
35901 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35902 wxPyEndAllowThreads(__tstate);
35903 if (PyErr_Occurred()) SWIG_fail;
35904 }
35905 {
35906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35907 }
35908 return resultobj;
35909 fail:
35910 return NULL;
35911 }
35912
35913
35914 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35915 PyObject *resultobj = 0;
35916 wxWindow *arg1 = (wxWindow *) 0 ;
35917 wxMenu *arg2 = (wxMenu *) 0 ;
35918 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35919 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35920 bool result;
35921 void *argp1 = 0 ;
35922 int res1 = 0 ;
35923 void *argp2 = 0 ;
35924 int res2 = 0 ;
35925 wxPoint temp3 ;
35926 PyObject * obj0 = 0 ;
35927 PyObject * obj1 = 0 ;
35928 PyObject * obj2 = 0 ;
35929 char * kwnames[] = {
35930 (char *) "self",(char *) "menu",(char *) "pos", NULL
35931 };
35932
35933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35935 if (!SWIG_IsOK(res1)) {
35936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
35937 }
35938 arg1 = reinterpret_cast< wxWindow * >(argp1);
35939 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35940 if (!SWIG_IsOK(res2)) {
35941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
35942 }
35943 arg2 = reinterpret_cast< wxMenu * >(argp2);
35944 if (obj2) {
35945 {
35946 arg3 = &temp3;
35947 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
35948 }
35949 }
35950 {
35951 PyThreadState* __tstate = wxPyBeginAllowThreads();
35952 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
35953 wxPyEndAllowThreads(__tstate);
35954 if (PyErr_Occurred()) SWIG_fail;
35955 }
35956 {
35957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35958 }
35959 return resultobj;
35960 fail:
35961 return NULL;
35962 }
35963
35964
35965 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35966 PyObject *resultobj = 0;
35967 wxWindow *arg1 = (wxWindow *) 0 ;
35968 long result;
35969 void *argp1 = 0 ;
35970 int res1 = 0 ;
35971 PyObject *swig_obj[1] ;
35972
35973 if (!args) SWIG_fail;
35974 swig_obj[0] = args;
35975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35976 if (!SWIG_IsOK(res1)) {
35977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35978 }
35979 arg1 = reinterpret_cast< wxWindow * >(argp1);
35980 {
35981 PyThreadState* __tstate = wxPyBeginAllowThreads();
35982 result = (long)wxWindow_GetHandle(arg1);
35983 wxPyEndAllowThreads(__tstate);
35984 if (PyErr_Occurred()) SWIG_fail;
35985 }
35986 resultobj = SWIG_From_long(static_cast< long >(result));
35987 return resultobj;
35988 fail:
35989 return NULL;
35990 }
35991
35992
35993 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35994 PyObject *resultobj = 0;
35995 wxWindow *arg1 = (wxWindow *) 0 ;
35996 long arg2 ;
35997 void *argp1 = 0 ;
35998 int res1 = 0 ;
35999 long val2 ;
36000 int ecode2 = 0 ;
36001 PyObject * obj0 = 0 ;
36002 PyObject * obj1 = 0 ;
36003 char * kwnames[] = {
36004 (char *) "self",(char *) "handle", NULL
36005 };
36006
36007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36009 if (!SWIG_IsOK(res1)) {
36010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36011 }
36012 arg1 = reinterpret_cast< wxWindow * >(argp1);
36013 ecode2 = SWIG_AsVal_long(obj1, &val2);
36014 if (!SWIG_IsOK(ecode2)) {
36015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36016 }
36017 arg2 = static_cast< long >(val2);
36018 {
36019 PyThreadState* __tstate = wxPyBeginAllowThreads();
36020 wxWindow_AssociateHandle(arg1,arg2);
36021 wxPyEndAllowThreads(__tstate);
36022 if (PyErr_Occurred()) SWIG_fail;
36023 }
36024 resultobj = SWIG_Py_Void();
36025 return resultobj;
36026 fail:
36027 return NULL;
36028 }
36029
36030
36031 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36032 PyObject *resultobj = 0;
36033 wxWindow *arg1 = (wxWindow *) 0 ;
36034 void *argp1 = 0 ;
36035 int res1 = 0 ;
36036 PyObject *swig_obj[1] ;
36037
36038 if (!args) SWIG_fail;
36039 swig_obj[0] = args;
36040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36041 if (!SWIG_IsOK(res1)) {
36042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36043 }
36044 arg1 = reinterpret_cast< wxWindow * >(argp1);
36045 {
36046 PyThreadState* __tstate = wxPyBeginAllowThreads();
36047 (arg1)->DissociateHandle();
36048 wxPyEndAllowThreads(__tstate);
36049 if (PyErr_Occurred()) SWIG_fail;
36050 }
36051 resultobj = SWIG_Py_Void();
36052 return resultobj;
36053 fail:
36054 return NULL;
36055 }
36056
36057
36058 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36059 PyObject *resultobj = 0;
36060 wxWindow *arg1 = (wxWindow *) 0 ;
36061 int arg2 ;
36062 bool result;
36063 void *argp1 = 0 ;
36064 int res1 = 0 ;
36065 int val2 ;
36066 int ecode2 = 0 ;
36067 PyObject * obj0 = 0 ;
36068 PyObject * obj1 = 0 ;
36069 char * kwnames[] = {
36070 (char *) "self",(char *) "orient", NULL
36071 };
36072
36073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36075 if (!SWIG_IsOK(res1)) {
36076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36077 }
36078 arg1 = reinterpret_cast< wxWindow * >(argp1);
36079 ecode2 = SWIG_AsVal_int(obj1, &val2);
36080 if (!SWIG_IsOK(ecode2)) {
36081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36082 }
36083 arg2 = static_cast< int >(val2);
36084 {
36085 PyThreadState* __tstate = wxPyBeginAllowThreads();
36086 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36087 wxPyEndAllowThreads(__tstate);
36088 if (PyErr_Occurred()) SWIG_fail;
36089 }
36090 {
36091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36092 }
36093 return resultobj;
36094 fail:
36095 return NULL;
36096 }
36097
36098
36099 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36100 PyObject *resultobj = 0;
36101 wxWindow *arg1 = (wxWindow *) 0 ;
36102 int arg2 ;
36103 int arg3 ;
36104 int arg4 ;
36105 int arg5 ;
36106 bool arg6 = (bool) true ;
36107 void *argp1 = 0 ;
36108 int res1 = 0 ;
36109 int val2 ;
36110 int ecode2 = 0 ;
36111 int val3 ;
36112 int ecode3 = 0 ;
36113 int val4 ;
36114 int ecode4 = 0 ;
36115 int val5 ;
36116 int ecode5 = 0 ;
36117 bool val6 ;
36118 int ecode6 = 0 ;
36119 PyObject * obj0 = 0 ;
36120 PyObject * obj1 = 0 ;
36121 PyObject * obj2 = 0 ;
36122 PyObject * obj3 = 0 ;
36123 PyObject * obj4 = 0 ;
36124 PyObject * obj5 = 0 ;
36125 char * kwnames[] = {
36126 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36127 };
36128
36129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36131 if (!SWIG_IsOK(res1)) {
36132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36133 }
36134 arg1 = reinterpret_cast< wxWindow * >(argp1);
36135 ecode2 = SWIG_AsVal_int(obj1, &val2);
36136 if (!SWIG_IsOK(ecode2)) {
36137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36138 }
36139 arg2 = static_cast< int >(val2);
36140 ecode3 = SWIG_AsVal_int(obj2, &val3);
36141 if (!SWIG_IsOK(ecode3)) {
36142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36143 }
36144 arg3 = static_cast< int >(val3);
36145 ecode4 = SWIG_AsVal_int(obj3, &val4);
36146 if (!SWIG_IsOK(ecode4)) {
36147 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36148 }
36149 arg4 = static_cast< int >(val4);
36150 ecode5 = SWIG_AsVal_int(obj4, &val5);
36151 if (!SWIG_IsOK(ecode5)) {
36152 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36153 }
36154 arg5 = static_cast< int >(val5);
36155 if (obj5) {
36156 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36157 if (!SWIG_IsOK(ecode6)) {
36158 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36159 }
36160 arg6 = static_cast< bool >(val6);
36161 }
36162 {
36163 PyThreadState* __tstate = wxPyBeginAllowThreads();
36164 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36165 wxPyEndAllowThreads(__tstate);
36166 if (PyErr_Occurred()) SWIG_fail;
36167 }
36168 resultobj = SWIG_Py_Void();
36169 return resultobj;
36170 fail:
36171 return NULL;
36172 }
36173
36174
36175 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36176 PyObject *resultobj = 0;
36177 wxWindow *arg1 = (wxWindow *) 0 ;
36178 int arg2 ;
36179 int arg3 ;
36180 bool arg4 = (bool) true ;
36181 void *argp1 = 0 ;
36182 int res1 = 0 ;
36183 int val2 ;
36184 int ecode2 = 0 ;
36185 int val3 ;
36186 int ecode3 = 0 ;
36187 bool val4 ;
36188 int ecode4 = 0 ;
36189 PyObject * obj0 = 0 ;
36190 PyObject * obj1 = 0 ;
36191 PyObject * obj2 = 0 ;
36192 PyObject * obj3 = 0 ;
36193 char * kwnames[] = {
36194 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36195 };
36196
36197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36199 if (!SWIG_IsOK(res1)) {
36200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36201 }
36202 arg1 = reinterpret_cast< wxWindow * >(argp1);
36203 ecode2 = SWIG_AsVal_int(obj1, &val2);
36204 if (!SWIG_IsOK(ecode2)) {
36205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36206 }
36207 arg2 = static_cast< int >(val2);
36208 ecode3 = SWIG_AsVal_int(obj2, &val3);
36209 if (!SWIG_IsOK(ecode3)) {
36210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36211 }
36212 arg3 = static_cast< int >(val3);
36213 if (obj3) {
36214 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36215 if (!SWIG_IsOK(ecode4)) {
36216 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36217 }
36218 arg4 = static_cast< bool >(val4);
36219 }
36220 {
36221 PyThreadState* __tstate = wxPyBeginAllowThreads();
36222 (arg1)->SetScrollPos(arg2,arg3,arg4);
36223 wxPyEndAllowThreads(__tstate);
36224 if (PyErr_Occurred()) SWIG_fail;
36225 }
36226 resultobj = SWIG_Py_Void();
36227 return resultobj;
36228 fail:
36229 return NULL;
36230 }
36231
36232
36233 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36234 PyObject *resultobj = 0;
36235 wxWindow *arg1 = (wxWindow *) 0 ;
36236 int arg2 ;
36237 int result;
36238 void *argp1 = 0 ;
36239 int res1 = 0 ;
36240 int val2 ;
36241 int ecode2 = 0 ;
36242 PyObject * obj0 = 0 ;
36243 PyObject * obj1 = 0 ;
36244 char * kwnames[] = {
36245 (char *) "self",(char *) "orientation", NULL
36246 };
36247
36248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36250 if (!SWIG_IsOK(res1)) {
36251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36252 }
36253 arg1 = reinterpret_cast< wxWindow * >(argp1);
36254 ecode2 = SWIG_AsVal_int(obj1, &val2);
36255 if (!SWIG_IsOK(ecode2)) {
36256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36257 }
36258 arg2 = static_cast< int >(val2);
36259 {
36260 PyThreadState* __tstate = wxPyBeginAllowThreads();
36261 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36262 wxPyEndAllowThreads(__tstate);
36263 if (PyErr_Occurred()) SWIG_fail;
36264 }
36265 resultobj = SWIG_From_int(static_cast< int >(result));
36266 return resultobj;
36267 fail:
36268 return NULL;
36269 }
36270
36271
36272 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36273 PyObject *resultobj = 0;
36274 wxWindow *arg1 = (wxWindow *) 0 ;
36275 int arg2 ;
36276 int result;
36277 void *argp1 = 0 ;
36278 int res1 = 0 ;
36279 int val2 ;
36280 int ecode2 = 0 ;
36281 PyObject * obj0 = 0 ;
36282 PyObject * obj1 = 0 ;
36283 char * kwnames[] = {
36284 (char *) "self",(char *) "orientation", NULL
36285 };
36286
36287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36289 if (!SWIG_IsOK(res1)) {
36290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36291 }
36292 arg1 = reinterpret_cast< wxWindow * >(argp1);
36293 ecode2 = SWIG_AsVal_int(obj1, &val2);
36294 if (!SWIG_IsOK(ecode2)) {
36295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36296 }
36297 arg2 = static_cast< int >(val2);
36298 {
36299 PyThreadState* __tstate = wxPyBeginAllowThreads();
36300 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36301 wxPyEndAllowThreads(__tstate);
36302 if (PyErr_Occurred()) SWIG_fail;
36303 }
36304 resultobj = SWIG_From_int(static_cast< int >(result));
36305 return resultobj;
36306 fail:
36307 return NULL;
36308 }
36309
36310
36311 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36312 PyObject *resultobj = 0;
36313 wxWindow *arg1 = (wxWindow *) 0 ;
36314 int arg2 ;
36315 int result;
36316 void *argp1 = 0 ;
36317 int res1 = 0 ;
36318 int val2 ;
36319 int ecode2 = 0 ;
36320 PyObject * obj0 = 0 ;
36321 PyObject * obj1 = 0 ;
36322 char * kwnames[] = {
36323 (char *) "self",(char *) "orientation", NULL
36324 };
36325
36326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36328 if (!SWIG_IsOK(res1)) {
36329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36330 }
36331 arg1 = reinterpret_cast< wxWindow * >(argp1);
36332 ecode2 = SWIG_AsVal_int(obj1, &val2);
36333 if (!SWIG_IsOK(ecode2)) {
36334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36335 }
36336 arg2 = static_cast< int >(val2);
36337 {
36338 PyThreadState* __tstate = wxPyBeginAllowThreads();
36339 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36340 wxPyEndAllowThreads(__tstate);
36341 if (PyErr_Occurred()) SWIG_fail;
36342 }
36343 resultobj = SWIG_From_int(static_cast< int >(result));
36344 return resultobj;
36345 fail:
36346 return NULL;
36347 }
36348
36349
36350 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36351 PyObject *resultobj = 0;
36352 wxWindow *arg1 = (wxWindow *) 0 ;
36353 int arg2 ;
36354 int arg3 ;
36355 wxRect *arg4 = (wxRect *) NULL ;
36356 void *argp1 = 0 ;
36357 int res1 = 0 ;
36358 int val2 ;
36359 int ecode2 = 0 ;
36360 int val3 ;
36361 int ecode3 = 0 ;
36362 void *argp4 = 0 ;
36363 int res4 = 0 ;
36364 PyObject * obj0 = 0 ;
36365 PyObject * obj1 = 0 ;
36366 PyObject * obj2 = 0 ;
36367 PyObject * obj3 = 0 ;
36368 char * kwnames[] = {
36369 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36370 };
36371
36372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36374 if (!SWIG_IsOK(res1)) {
36375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36376 }
36377 arg1 = reinterpret_cast< wxWindow * >(argp1);
36378 ecode2 = SWIG_AsVal_int(obj1, &val2);
36379 if (!SWIG_IsOK(ecode2)) {
36380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36381 }
36382 arg2 = static_cast< int >(val2);
36383 ecode3 = SWIG_AsVal_int(obj2, &val3);
36384 if (!SWIG_IsOK(ecode3)) {
36385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36386 }
36387 arg3 = static_cast< int >(val3);
36388 if (obj3) {
36389 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36390 if (!SWIG_IsOK(res4)) {
36391 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36392 }
36393 arg4 = reinterpret_cast< wxRect * >(argp4);
36394 }
36395 {
36396 PyThreadState* __tstate = wxPyBeginAllowThreads();
36397 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36398 wxPyEndAllowThreads(__tstate);
36399 if (PyErr_Occurred()) SWIG_fail;
36400 }
36401 resultobj = SWIG_Py_Void();
36402 return resultobj;
36403 fail:
36404 return NULL;
36405 }
36406
36407
36408 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36409 PyObject *resultobj = 0;
36410 wxWindow *arg1 = (wxWindow *) 0 ;
36411 int arg2 ;
36412 bool result;
36413 void *argp1 = 0 ;
36414 int res1 = 0 ;
36415 int val2 ;
36416 int ecode2 = 0 ;
36417 PyObject * obj0 = 0 ;
36418 PyObject * obj1 = 0 ;
36419 char * kwnames[] = {
36420 (char *) "self",(char *) "lines", NULL
36421 };
36422
36423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36425 if (!SWIG_IsOK(res1)) {
36426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36427 }
36428 arg1 = reinterpret_cast< wxWindow * >(argp1);
36429 ecode2 = SWIG_AsVal_int(obj1, &val2);
36430 if (!SWIG_IsOK(ecode2)) {
36431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36432 }
36433 arg2 = static_cast< int >(val2);
36434 {
36435 PyThreadState* __tstate = wxPyBeginAllowThreads();
36436 result = (bool)(arg1)->ScrollLines(arg2);
36437 wxPyEndAllowThreads(__tstate);
36438 if (PyErr_Occurred()) SWIG_fail;
36439 }
36440 {
36441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36442 }
36443 return resultobj;
36444 fail:
36445 return NULL;
36446 }
36447
36448
36449 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36450 PyObject *resultobj = 0;
36451 wxWindow *arg1 = (wxWindow *) 0 ;
36452 int arg2 ;
36453 bool result;
36454 void *argp1 = 0 ;
36455 int res1 = 0 ;
36456 int val2 ;
36457 int ecode2 = 0 ;
36458 PyObject * obj0 = 0 ;
36459 PyObject * obj1 = 0 ;
36460 char * kwnames[] = {
36461 (char *) "self",(char *) "pages", NULL
36462 };
36463
36464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36466 if (!SWIG_IsOK(res1)) {
36467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36468 }
36469 arg1 = reinterpret_cast< wxWindow * >(argp1);
36470 ecode2 = SWIG_AsVal_int(obj1, &val2);
36471 if (!SWIG_IsOK(ecode2)) {
36472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36473 }
36474 arg2 = static_cast< int >(val2);
36475 {
36476 PyThreadState* __tstate = wxPyBeginAllowThreads();
36477 result = (bool)(arg1)->ScrollPages(arg2);
36478 wxPyEndAllowThreads(__tstate);
36479 if (PyErr_Occurred()) SWIG_fail;
36480 }
36481 {
36482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36483 }
36484 return resultobj;
36485 fail:
36486 return NULL;
36487 }
36488
36489
36490 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36491 PyObject *resultobj = 0;
36492 wxWindow *arg1 = (wxWindow *) 0 ;
36493 bool result;
36494 void *argp1 = 0 ;
36495 int res1 = 0 ;
36496 PyObject *swig_obj[1] ;
36497
36498 if (!args) SWIG_fail;
36499 swig_obj[0] = args;
36500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36501 if (!SWIG_IsOK(res1)) {
36502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36503 }
36504 arg1 = reinterpret_cast< wxWindow * >(argp1);
36505 {
36506 PyThreadState* __tstate = wxPyBeginAllowThreads();
36507 result = (bool)(arg1)->LineUp();
36508 wxPyEndAllowThreads(__tstate);
36509 if (PyErr_Occurred()) SWIG_fail;
36510 }
36511 {
36512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36513 }
36514 return resultobj;
36515 fail:
36516 return NULL;
36517 }
36518
36519
36520 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36521 PyObject *resultobj = 0;
36522 wxWindow *arg1 = (wxWindow *) 0 ;
36523 bool result;
36524 void *argp1 = 0 ;
36525 int res1 = 0 ;
36526 PyObject *swig_obj[1] ;
36527
36528 if (!args) SWIG_fail;
36529 swig_obj[0] = args;
36530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36531 if (!SWIG_IsOK(res1)) {
36532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36533 }
36534 arg1 = reinterpret_cast< wxWindow * >(argp1);
36535 {
36536 PyThreadState* __tstate = wxPyBeginAllowThreads();
36537 result = (bool)(arg1)->LineDown();
36538 wxPyEndAllowThreads(__tstate);
36539 if (PyErr_Occurred()) SWIG_fail;
36540 }
36541 {
36542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36543 }
36544 return resultobj;
36545 fail:
36546 return NULL;
36547 }
36548
36549
36550 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36551 PyObject *resultobj = 0;
36552 wxWindow *arg1 = (wxWindow *) 0 ;
36553 bool result;
36554 void *argp1 = 0 ;
36555 int res1 = 0 ;
36556 PyObject *swig_obj[1] ;
36557
36558 if (!args) SWIG_fail;
36559 swig_obj[0] = args;
36560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36561 if (!SWIG_IsOK(res1)) {
36562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36563 }
36564 arg1 = reinterpret_cast< wxWindow * >(argp1);
36565 {
36566 PyThreadState* __tstate = wxPyBeginAllowThreads();
36567 result = (bool)(arg1)->PageUp();
36568 wxPyEndAllowThreads(__tstate);
36569 if (PyErr_Occurred()) SWIG_fail;
36570 }
36571 {
36572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36573 }
36574 return resultobj;
36575 fail:
36576 return NULL;
36577 }
36578
36579
36580 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36581 PyObject *resultobj = 0;
36582 wxWindow *arg1 = (wxWindow *) 0 ;
36583 bool result;
36584 void *argp1 = 0 ;
36585 int res1 = 0 ;
36586 PyObject *swig_obj[1] ;
36587
36588 if (!args) SWIG_fail;
36589 swig_obj[0] = args;
36590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36591 if (!SWIG_IsOK(res1)) {
36592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36593 }
36594 arg1 = reinterpret_cast< wxWindow * >(argp1);
36595 {
36596 PyThreadState* __tstate = wxPyBeginAllowThreads();
36597 result = (bool)(arg1)->PageDown();
36598 wxPyEndAllowThreads(__tstate);
36599 if (PyErr_Occurred()) SWIG_fail;
36600 }
36601 {
36602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36603 }
36604 return resultobj;
36605 fail:
36606 return NULL;
36607 }
36608
36609
36610 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36611 PyObject *resultobj = 0;
36612 wxWindow *arg1 = (wxWindow *) 0 ;
36613 wxString *arg2 = 0 ;
36614 void *argp1 = 0 ;
36615 int res1 = 0 ;
36616 bool temp2 = false ;
36617 PyObject * obj0 = 0 ;
36618 PyObject * obj1 = 0 ;
36619 char * kwnames[] = {
36620 (char *) "self",(char *) "text", NULL
36621 };
36622
36623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36625 if (!SWIG_IsOK(res1)) {
36626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36627 }
36628 arg1 = reinterpret_cast< wxWindow * >(argp1);
36629 {
36630 arg2 = wxString_in_helper(obj1);
36631 if (arg2 == NULL) SWIG_fail;
36632 temp2 = true;
36633 }
36634 {
36635 PyThreadState* __tstate = wxPyBeginAllowThreads();
36636 (arg1)->SetHelpText((wxString const &)*arg2);
36637 wxPyEndAllowThreads(__tstate);
36638 if (PyErr_Occurred()) SWIG_fail;
36639 }
36640 resultobj = SWIG_Py_Void();
36641 {
36642 if (temp2)
36643 delete arg2;
36644 }
36645 return resultobj;
36646 fail:
36647 {
36648 if (temp2)
36649 delete arg2;
36650 }
36651 return NULL;
36652 }
36653
36654
36655 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36656 PyObject *resultobj = 0;
36657 wxWindow *arg1 = (wxWindow *) 0 ;
36658 wxString *arg2 = 0 ;
36659 void *argp1 = 0 ;
36660 int res1 = 0 ;
36661 bool temp2 = false ;
36662 PyObject * obj0 = 0 ;
36663 PyObject * obj1 = 0 ;
36664 char * kwnames[] = {
36665 (char *) "self",(char *) "text", NULL
36666 };
36667
36668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36670 if (!SWIG_IsOK(res1)) {
36671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36672 }
36673 arg1 = reinterpret_cast< wxWindow * >(argp1);
36674 {
36675 arg2 = wxString_in_helper(obj1);
36676 if (arg2 == NULL) SWIG_fail;
36677 temp2 = true;
36678 }
36679 {
36680 PyThreadState* __tstate = wxPyBeginAllowThreads();
36681 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36682 wxPyEndAllowThreads(__tstate);
36683 if (PyErr_Occurred()) SWIG_fail;
36684 }
36685 resultobj = SWIG_Py_Void();
36686 {
36687 if (temp2)
36688 delete arg2;
36689 }
36690 return resultobj;
36691 fail:
36692 {
36693 if (temp2)
36694 delete arg2;
36695 }
36696 return NULL;
36697 }
36698
36699
36700 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36701 PyObject *resultobj = 0;
36702 wxWindow *arg1 = (wxWindow *) 0 ;
36703 wxString result;
36704 void *argp1 = 0 ;
36705 int res1 = 0 ;
36706 PyObject *swig_obj[1] ;
36707
36708 if (!args) SWIG_fail;
36709 swig_obj[0] = args;
36710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36711 if (!SWIG_IsOK(res1)) {
36712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36713 }
36714 arg1 = reinterpret_cast< wxWindow * >(argp1);
36715 {
36716 PyThreadState* __tstate = wxPyBeginAllowThreads();
36717 result = ((wxWindow const *)arg1)->GetHelpText();
36718 wxPyEndAllowThreads(__tstate);
36719 if (PyErr_Occurred()) SWIG_fail;
36720 }
36721 {
36722 #if wxUSE_UNICODE
36723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36724 #else
36725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36726 #endif
36727 }
36728 return resultobj;
36729 fail:
36730 return NULL;
36731 }
36732
36733
36734 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36735 PyObject *resultobj = 0;
36736 wxWindow *arg1 = (wxWindow *) 0 ;
36737 wxString *arg2 = 0 ;
36738 void *argp1 = 0 ;
36739 int res1 = 0 ;
36740 bool temp2 = false ;
36741 PyObject * obj0 = 0 ;
36742 PyObject * obj1 = 0 ;
36743 char * kwnames[] = {
36744 (char *) "self",(char *) "tip", NULL
36745 };
36746
36747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36749 if (!SWIG_IsOK(res1)) {
36750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36751 }
36752 arg1 = reinterpret_cast< wxWindow * >(argp1);
36753 {
36754 arg2 = wxString_in_helper(obj1);
36755 if (arg2 == NULL) SWIG_fail;
36756 temp2 = true;
36757 }
36758 {
36759 PyThreadState* __tstate = wxPyBeginAllowThreads();
36760 (arg1)->SetToolTip((wxString const &)*arg2);
36761 wxPyEndAllowThreads(__tstate);
36762 if (PyErr_Occurred()) SWIG_fail;
36763 }
36764 resultobj = SWIG_Py_Void();
36765 {
36766 if (temp2)
36767 delete arg2;
36768 }
36769 return resultobj;
36770 fail:
36771 {
36772 if (temp2)
36773 delete arg2;
36774 }
36775 return NULL;
36776 }
36777
36778
36779 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36780 PyObject *resultobj = 0;
36781 wxWindow *arg1 = (wxWindow *) 0 ;
36782 wxToolTip *arg2 = (wxToolTip *) 0 ;
36783 void *argp1 = 0 ;
36784 int res1 = 0 ;
36785 int res2 = 0 ;
36786 PyObject * obj0 = 0 ;
36787 PyObject * obj1 = 0 ;
36788 char * kwnames[] = {
36789 (char *) "self",(char *) "tip", NULL
36790 };
36791
36792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36794 if (!SWIG_IsOK(res1)) {
36795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36796 }
36797 arg1 = reinterpret_cast< wxWindow * >(argp1);
36798 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36799 if (!SWIG_IsOK(res2)) {
36800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36801 }
36802 {
36803 PyThreadState* __tstate = wxPyBeginAllowThreads();
36804 (arg1)->SetToolTip(arg2);
36805 wxPyEndAllowThreads(__tstate);
36806 if (PyErr_Occurred()) SWIG_fail;
36807 }
36808 resultobj = SWIG_Py_Void();
36809 return resultobj;
36810 fail:
36811 return NULL;
36812 }
36813
36814
36815 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36816 PyObject *resultobj = 0;
36817 wxWindow *arg1 = (wxWindow *) 0 ;
36818 wxToolTip *result = 0 ;
36819 void *argp1 = 0 ;
36820 int res1 = 0 ;
36821 PyObject *swig_obj[1] ;
36822
36823 if (!args) SWIG_fail;
36824 swig_obj[0] = args;
36825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36826 if (!SWIG_IsOK(res1)) {
36827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36828 }
36829 arg1 = reinterpret_cast< wxWindow * >(argp1);
36830 {
36831 PyThreadState* __tstate = wxPyBeginAllowThreads();
36832 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36833 wxPyEndAllowThreads(__tstate);
36834 if (PyErr_Occurred()) SWIG_fail;
36835 }
36836 {
36837 resultobj = wxPyMake_wxObject(result, (bool)0);
36838 }
36839 return resultobj;
36840 fail:
36841 return NULL;
36842 }
36843
36844
36845 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36846 PyObject *resultobj = 0;
36847 wxWindow *arg1 = (wxWindow *) 0 ;
36848 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36849 void *argp1 = 0 ;
36850 int res1 = 0 ;
36851 int res2 = 0 ;
36852 PyObject * obj0 = 0 ;
36853 PyObject * obj1 = 0 ;
36854 char * kwnames[] = {
36855 (char *) "self",(char *) "dropTarget", NULL
36856 };
36857
36858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36860 if (!SWIG_IsOK(res1)) {
36861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36862 }
36863 arg1 = reinterpret_cast< wxWindow * >(argp1);
36864 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36865 if (!SWIG_IsOK(res2)) {
36866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36867 }
36868 {
36869 PyThreadState* __tstate = wxPyBeginAllowThreads();
36870 (arg1)->SetDropTarget(arg2);
36871 wxPyEndAllowThreads(__tstate);
36872 if (PyErr_Occurred()) SWIG_fail;
36873 }
36874 resultobj = SWIG_Py_Void();
36875 return resultobj;
36876 fail:
36877 return NULL;
36878 }
36879
36880
36881 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36882 PyObject *resultobj = 0;
36883 wxWindow *arg1 = (wxWindow *) 0 ;
36884 wxPyDropTarget *result = 0 ;
36885 void *argp1 = 0 ;
36886 int res1 = 0 ;
36887 PyObject *swig_obj[1] ;
36888
36889 if (!args) SWIG_fail;
36890 swig_obj[0] = args;
36891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36892 if (!SWIG_IsOK(res1)) {
36893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36894 }
36895 arg1 = reinterpret_cast< wxWindow * >(argp1);
36896 {
36897 PyThreadState* __tstate = wxPyBeginAllowThreads();
36898 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36899 wxPyEndAllowThreads(__tstate);
36900 if (PyErr_Occurred()) SWIG_fail;
36901 }
36902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36903 return resultobj;
36904 fail:
36905 return NULL;
36906 }
36907
36908
36909 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36910 PyObject *resultobj = 0;
36911 wxWindow *arg1 = (wxWindow *) 0 ;
36912 bool arg2 ;
36913 void *argp1 = 0 ;
36914 int res1 = 0 ;
36915 bool val2 ;
36916 int ecode2 = 0 ;
36917 PyObject * obj0 = 0 ;
36918 PyObject * obj1 = 0 ;
36919 char * kwnames[] = {
36920 (char *) "self",(char *) "accept", NULL
36921 };
36922
36923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
36924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36925 if (!SWIG_IsOK(res1)) {
36926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
36927 }
36928 arg1 = reinterpret_cast< wxWindow * >(argp1);
36929 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36930 if (!SWIG_IsOK(ecode2)) {
36931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
36932 }
36933 arg2 = static_cast< bool >(val2);
36934 {
36935 PyThreadState* __tstate = wxPyBeginAllowThreads();
36936 wxWindow_DragAcceptFiles(arg1,arg2);
36937 wxPyEndAllowThreads(__tstate);
36938 if (PyErr_Occurred()) SWIG_fail;
36939 }
36940 resultobj = SWIG_Py_Void();
36941 return resultobj;
36942 fail:
36943 return NULL;
36944 }
36945
36946
36947 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36948 PyObject *resultobj = 0;
36949 wxWindow *arg1 = (wxWindow *) 0 ;
36950 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
36951 void *argp1 = 0 ;
36952 int res1 = 0 ;
36953 int res2 = 0 ;
36954 PyObject * obj0 = 0 ;
36955 PyObject * obj1 = 0 ;
36956 char * kwnames[] = {
36957 (char *) "self",(char *) "constraints", NULL
36958 };
36959
36960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
36961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36962 if (!SWIG_IsOK(res1)) {
36963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
36964 }
36965 arg1 = reinterpret_cast< wxWindow * >(argp1);
36966 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
36967 if (!SWIG_IsOK(res2)) {
36968 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
36969 }
36970 {
36971 PyThreadState* __tstate = wxPyBeginAllowThreads();
36972 (arg1)->SetConstraints(arg2);
36973 wxPyEndAllowThreads(__tstate);
36974 if (PyErr_Occurred()) SWIG_fail;
36975 }
36976 resultobj = SWIG_Py_Void();
36977 return resultobj;
36978 fail:
36979 return NULL;
36980 }
36981
36982
36983 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36984 PyObject *resultobj = 0;
36985 wxWindow *arg1 = (wxWindow *) 0 ;
36986 wxLayoutConstraints *result = 0 ;
36987 void *argp1 = 0 ;
36988 int res1 = 0 ;
36989 PyObject *swig_obj[1] ;
36990
36991 if (!args) SWIG_fail;
36992 swig_obj[0] = args;
36993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36994 if (!SWIG_IsOK(res1)) {
36995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
36996 }
36997 arg1 = reinterpret_cast< wxWindow * >(argp1);
36998 {
36999 PyThreadState* __tstate = wxPyBeginAllowThreads();
37000 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37001 wxPyEndAllowThreads(__tstate);
37002 if (PyErr_Occurred()) SWIG_fail;
37003 }
37004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37005 return resultobj;
37006 fail:
37007 return NULL;
37008 }
37009
37010
37011 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37012 PyObject *resultobj = 0;
37013 wxWindow *arg1 = (wxWindow *) 0 ;
37014 bool arg2 ;
37015 void *argp1 = 0 ;
37016 int res1 = 0 ;
37017 bool val2 ;
37018 int ecode2 = 0 ;
37019 PyObject * obj0 = 0 ;
37020 PyObject * obj1 = 0 ;
37021 char * kwnames[] = {
37022 (char *) "self",(char *) "autoLayout", NULL
37023 };
37024
37025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37027 if (!SWIG_IsOK(res1)) {
37028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37029 }
37030 arg1 = reinterpret_cast< wxWindow * >(argp1);
37031 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37032 if (!SWIG_IsOK(ecode2)) {
37033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37034 }
37035 arg2 = static_cast< bool >(val2);
37036 {
37037 PyThreadState* __tstate = wxPyBeginAllowThreads();
37038 (arg1)->SetAutoLayout(arg2);
37039 wxPyEndAllowThreads(__tstate);
37040 if (PyErr_Occurred()) SWIG_fail;
37041 }
37042 resultobj = SWIG_Py_Void();
37043 return resultobj;
37044 fail:
37045 return NULL;
37046 }
37047
37048
37049 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37050 PyObject *resultobj = 0;
37051 wxWindow *arg1 = (wxWindow *) 0 ;
37052 bool result;
37053 void *argp1 = 0 ;
37054 int res1 = 0 ;
37055 PyObject *swig_obj[1] ;
37056
37057 if (!args) SWIG_fail;
37058 swig_obj[0] = args;
37059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37060 if (!SWIG_IsOK(res1)) {
37061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37062 }
37063 arg1 = reinterpret_cast< wxWindow * >(argp1);
37064 {
37065 PyThreadState* __tstate = wxPyBeginAllowThreads();
37066 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37067 wxPyEndAllowThreads(__tstate);
37068 if (PyErr_Occurred()) SWIG_fail;
37069 }
37070 {
37071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37072 }
37073 return resultobj;
37074 fail:
37075 return NULL;
37076 }
37077
37078
37079 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37080 PyObject *resultobj = 0;
37081 wxWindow *arg1 = (wxWindow *) 0 ;
37082 bool result;
37083 void *argp1 = 0 ;
37084 int res1 = 0 ;
37085 PyObject *swig_obj[1] ;
37086
37087 if (!args) SWIG_fail;
37088 swig_obj[0] = args;
37089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37090 if (!SWIG_IsOK(res1)) {
37091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37092 }
37093 arg1 = reinterpret_cast< wxWindow * >(argp1);
37094 {
37095 PyThreadState* __tstate = wxPyBeginAllowThreads();
37096 result = (bool)(arg1)->Layout();
37097 wxPyEndAllowThreads(__tstate);
37098 if (PyErr_Occurred()) SWIG_fail;
37099 }
37100 {
37101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37102 }
37103 return resultobj;
37104 fail:
37105 return NULL;
37106 }
37107
37108
37109 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37110 PyObject *resultobj = 0;
37111 wxWindow *arg1 = (wxWindow *) 0 ;
37112 wxSizer *arg2 = (wxSizer *) 0 ;
37113 bool arg3 = (bool) true ;
37114 void *argp1 = 0 ;
37115 int res1 = 0 ;
37116 int res2 = 0 ;
37117 bool val3 ;
37118 int ecode3 = 0 ;
37119 PyObject * obj0 = 0 ;
37120 PyObject * obj1 = 0 ;
37121 PyObject * obj2 = 0 ;
37122 char * kwnames[] = {
37123 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37124 };
37125
37126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37128 if (!SWIG_IsOK(res1)) {
37129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37130 }
37131 arg1 = reinterpret_cast< wxWindow * >(argp1);
37132 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37133 if (!SWIG_IsOK(res2)) {
37134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37135 }
37136 if (obj2) {
37137 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37138 if (!SWIG_IsOK(ecode3)) {
37139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37140 }
37141 arg3 = static_cast< bool >(val3);
37142 }
37143 {
37144 PyThreadState* __tstate = wxPyBeginAllowThreads();
37145 (arg1)->SetSizer(arg2,arg3);
37146 wxPyEndAllowThreads(__tstate);
37147 if (PyErr_Occurred()) SWIG_fail;
37148 }
37149 resultobj = SWIG_Py_Void();
37150 return resultobj;
37151 fail:
37152 return NULL;
37153 }
37154
37155
37156 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37157 PyObject *resultobj = 0;
37158 wxWindow *arg1 = (wxWindow *) 0 ;
37159 wxSizer *arg2 = (wxSizer *) 0 ;
37160 bool arg3 = (bool) true ;
37161 void *argp1 = 0 ;
37162 int res1 = 0 ;
37163 int res2 = 0 ;
37164 bool val3 ;
37165 int ecode3 = 0 ;
37166 PyObject * obj0 = 0 ;
37167 PyObject * obj1 = 0 ;
37168 PyObject * obj2 = 0 ;
37169 char * kwnames[] = {
37170 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37171 };
37172
37173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37175 if (!SWIG_IsOK(res1)) {
37176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37177 }
37178 arg1 = reinterpret_cast< wxWindow * >(argp1);
37179 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37180 if (!SWIG_IsOK(res2)) {
37181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37182 }
37183 if (obj2) {
37184 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37185 if (!SWIG_IsOK(ecode3)) {
37186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37187 }
37188 arg3 = static_cast< bool >(val3);
37189 }
37190 {
37191 PyThreadState* __tstate = wxPyBeginAllowThreads();
37192 (arg1)->SetSizerAndFit(arg2,arg3);
37193 wxPyEndAllowThreads(__tstate);
37194 if (PyErr_Occurred()) SWIG_fail;
37195 }
37196 resultobj = SWIG_Py_Void();
37197 return resultobj;
37198 fail:
37199 return NULL;
37200 }
37201
37202
37203 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37204 PyObject *resultobj = 0;
37205 wxWindow *arg1 = (wxWindow *) 0 ;
37206 wxSizer *result = 0 ;
37207 void *argp1 = 0 ;
37208 int res1 = 0 ;
37209 PyObject *swig_obj[1] ;
37210
37211 if (!args) SWIG_fail;
37212 swig_obj[0] = args;
37213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37214 if (!SWIG_IsOK(res1)) {
37215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37216 }
37217 arg1 = reinterpret_cast< wxWindow * >(argp1);
37218 {
37219 PyThreadState* __tstate = wxPyBeginAllowThreads();
37220 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37221 wxPyEndAllowThreads(__tstate);
37222 if (PyErr_Occurred()) SWIG_fail;
37223 }
37224 {
37225 resultobj = wxPyMake_wxObject(result, (bool)0);
37226 }
37227 return resultobj;
37228 fail:
37229 return NULL;
37230 }
37231
37232
37233 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37234 PyObject *resultobj = 0;
37235 wxWindow *arg1 = (wxWindow *) 0 ;
37236 wxSizer *arg2 = (wxSizer *) 0 ;
37237 void *argp1 = 0 ;
37238 int res1 = 0 ;
37239 void *argp2 = 0 ;
37240 int res2 = 0 ;
37241 PyObject * obj0 = 0 ;
37242 PyObject * obj1 = 0 ;
37243 char * kwnames[] = {
37244 (char *) "self",(char *) "sizer", NULL
37245 };
37246
37247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37249 if (!SWIG_IsOK(res1)) {
37250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37251 }
37252 arg1 = reinterpret_cast< wxWindow * >(argp1);
37253 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37254 if (!SWIG_IsOK(res2)) {
37255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37256 }
37257 arg2 = reinterpret_cast< wxSizer * >(argp2);
37258 {
37259 PyThreadState* __tstate = wxPyBeginAllowThreads();
37260 (arg1)->SetContainingSizer(arg2);
37261 wxPyEndAllowThreads(__tstate);
37262 if (PyErr_Occurred()) SWIG_fail;
37263 }
37264 resultobj = SWIG_Py_Void();
37265 return resultobj;
37266 fail:
37267 return NULL;
37268 }
37269
37270
37271 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37272 PyObject *resultobj = 0;
37273 wxWindow *arg1 = (wxWindow *) 0 ;
37274 wxSizer *result = 0 ;
37275 void *argp1 = 0 ;
37276 int res1 = 0 ;
37277 PyObject *swig_obj[1] ;
37278
37279 if (!args) SWIG_fail;
37280 swig_obj[0] = args;
37281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37282 if (!SWIG_IsOK(res1)) {
37283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37284 }
37285 arg1 = reinterpret_cast< wxWindow * >(argp1);
37286 {
37287 PyThreadState* __tstate = wxPyBeginAllowThreads();
37288 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37289 wxPyEndAllowThreads(__tstate);
37290 if (PyErr_Occurred()) SWIG_fail;
37291 }
37292 {
37293 resultobj = wxPyMake_wxObject(result, (bool)0);
37294 }
37295 return resultobj;
37296 fail:
37297 return NULL;
37298 }
37299
37300
37301 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37302 PyObject *resultobj = 0;
37303 wxWindow *arg1 = (wxWindow *) 0 ;
37304 void *argp1 = 0 ;
37305 int res1 = 0 ;
37306 PyObject *swig_obj[1] ;
37307
37308 if (!args) SWIG_fail;
37309 swig_obj[0] = args;
37310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37311 if (!SWIG_IsOK(res1)) {
37312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37313 }
37314 arg1 = reinterpret_cast< wxWindow * >(argp1);
37315 {
37316 PyThreadState* __tstate = wxPyBeginAllowThreads();
37317 (arg1)->InheritAttributes();
37318 wxPyEndAllowThreads(__tstate);
37319 if (PyErr_Occurred()) SWIG_fail;
37320 }
37321 resultobj = SWIG_Py_Void();
37322 return resultobj;
37323 fail:
37324 return NULL;
37325 }
37326
37327
37328 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37329 PyObject *resultobj = 0;
37330 wxWindow *arg1 = (wxWindow *) 0 ;
37331 bool result;
37332 void *argp1 = 0 ;
37333 int res1 = 0 ;
37334 PyObject *swig_obj[1] ;
37335
37336 if (!args) SWIG_fail;
37337 swig_obj[0] = args;
37338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37339 if (!SWIG_IsOK(res1)) {
37340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37341 }
37342 arg1 = reinterpret_cast< wxWindow * >(argp1);
37343 {
37344 PyThreadState* __tstate = wxPyBeginAllowThreads();
37345 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37346 wxPyEndAllowThreads(__tstate);
37347 if (PyErr_Occurred()) SWIG_fail;
37348 }
37349 {
37350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37351 }
37352 return resultobj;
37353 fail:
37354 return NULL;
37355 }
37356
37357
37358 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37359 PyObject *obj;
37360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37361 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37362 return SWIG_Py_Void();
37363 }
37364
37365 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37366 return SWIG_Python_InitShadowInstance(args);
37367 }
37368
37369 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37370 PyObject *resultobj = 0;
37371 long arg1 ;
37372 wxWindow *arg2 = (wxWindow *) NULL ;
37373 wxWindow *result = 0 ;
37374 long val1 ;
37375 int ecode1 = 0 ;
37376 void *argp2 = 0 ;
37377 int res2 = 0 ;
37378 PyObject * obj0 = 0 ;
37379 PyObject * obj1 = 0 ;
37380 char * kwnames[] = {
37381 (char *) "id",(char *) "parent", NULL
37382 };
37383
37384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37385 ecode1 = SWIG_AsVal_long(obj0, &val1);
37386 if (!SWIG_IsOK(ecode1)) {
37387 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37388 }
37389 arg1 = static_cast< long >(val1);
37390 if (obj1) {
37391 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37392 if (!SWIG_IsOK(res2)) {
37393 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37394 }
37395 arg2 = reinterpret_cast< wxWindow * >(argp2);
37396 }
37397 {
37398 if (!wxPyCheckForApp()) SWIG_fail;
37399 PyThreadState* __tstate = wxPyBeginAllowThreads();
37400 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37401 wxPyEndAllowThreads(__tstate);
37402 if (PyErr_Occurred()) SWIG_fail;
37403 }
37404 {
37405 resultobj = wxPyMake_wxObject(result, 0);
37406 }
37407 return resultobj;
37408 fail:
37409 return NULL;
37410 }
37411
37412
37413 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37414 PyObject *resultobj = 0;
37415 wxString *arg1 = 0 ;
37416 wxWindow *arg2 = (wxWindow *) NULL ;
37417 wxWindow *result = 0 ;
37418 bool temp1 = false ;
37419 void *argp2 = 0 ;
37420 int res2 = 0 ;
37421 PyObject * obj0 = 0 ;
37422 PyObject * obj1 = 0 ;
37423 char * kwnames[] = {
37424 (char *) "name",(char *) "parent", NULL
37425 };
37426
37427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37428 {
37429 arg1 = wxString_in_helper(obj0);
37430 if (arg1 == NULL) SWIG_fail;
37431 temp1 = true;
37432 }
37433 if (obj1) {
37434 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37435 if (!SWIG_IsOK(res2)) {
37436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37437 }
37438 arg2 = reinterpret_cast< wxWindow * >(argp2);
37439 }
37440 {
37441 if (!wxPyCheckForApp()) SWIG_fail;
37442 PyThreadState* __tstate = wxPyBeginAllowThreads();
37443 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37444 wxPyEndAllowThreads(__tstate);
37445 if (PyErr_Occurred()) SWIG_fail;
37446 }
37447 {
37448 resultobj = wxPyMake_wxObject(result, 0);
37449 }
37450 {
37451 if (temp1)
37452 delete arg1;
37453 }
37454 return resultobj;
37455 fail:
37456 {
37457 if (temp1)
37458 delete arg1;
37459 }
37460 return NULL;
37461 }
37462
37463
37464 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37465 PyObject *resultobj = 0;
37466 wxString *arg1 = 0 ;
37467 wxWindow *arg2 = (wxWindow *) NULL ;
37468 wxWindow *result = 0 ;
37469 bool temp1 = false ;
37470 void *argp2 = 0 ;
37471 int res2 = 0 ;
37472 PyObject * obj0 = 0 ;
37473 PyObject * obj1 = 0 ;
37474 char * kwnames[] = {
37475 (char *) "label",(char *) "parent", NULL
37476 };
37477
37478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37479 {
37480 arg1 = wxString_in_helper(obj0);
37481 if (arg1 == NULL) SWIG_fail;
37482 temp1 = true;
37483 }
37484 if (obj1) {
37485 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37486 if (!SWIG_IsOK(res2)) {
37487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37488 }
37489 arg2 = reinterpret_cast< wxWindow * >(argp2);
37490 }
37491 {
37492 if (!wxPyCheckForApp()) SWIG_fail;
37493 PyThreadState* __tstate = wxPyBeginAllowThreads();
37494 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37495 wxPyEndAllowThreads(__tstate);
37496 if (PyErr_Occurred()) SWIG_fail;
37497 }
37498 {
37499 resultobj = wxPyMake_wxObject(result, 0);
37500 }
37501 {
37502 if (temp1)
37503 delete arg1;
37504 }
37505 return resultobj;
37506 fail:
37507 {
37508 if (temp1)
37509 delete arg1;
37510 }
37511 return NULL;
37512 }
37513
37514
37515 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37516 PyObject *resultobj = 0;
37517 wxWindow *arg1 = (wxWindow *) 0 ;
37518 unsigned long arg2 ;
37519 wxWindow *result = 0 ;
37520 void *argp1 = 0 ;
37521 int res1 = 0 ;
37522 unsigned long val2 ;
37523 int ecode2 = 0 ;
37524 PyObject * obj0 = 0 ;
37525 PyObject * obj1 = 0 ;
37526 char * kwnames[] = {
37527 (char *) "parent",(char *) "_hWnd", NULL
37528 };
37529
37530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37532 if (!SWIG_IsOK(res1)) {
37533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37534 }
37535 arg1 = reinterpret_cast< wxWindow * >(argp1);
37536 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37537 if (!SWIG_IsOK(ecode2)) {
37538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37539 }
37540 arg2 = static_cast< unsigned long >(val2);
37541 {
37542 PyThreadState* __tstate = wxPyBeginAllowThreads();
37543 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37544 wxPyEndAllowThreads(__tstate);
37545 if (PyErr_Occurred()) SWIG_fail;
37546 }
37547 {
37548 resultobj = wxPyMake_wxObject(result, 0);
37549 }
37550 return resultobj;
37551 fail:
37552 return NULL;
37553 }
37554
37555
37556 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37557 PyObject *resultobj = 0;
37558 PyObject *result = 0 ;
37559
37560 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37561 {
37562 PyThreadState* __tstate = wxPyBeginAllowThreads();
37563 result = (PyObject *)GetTopLevelWindows();
37564 wxPyEndAllowThreads(__tstate);
37565 if (PyErr_Occurred()) SWIG_fail;
37566 }
37567 resultobj = result;
37568 return resultobj;
37569 fail:
37570 return NULL;
37571 }
37572
37573
37574 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37575 PyObject *resultobj = 0;
37576 wxValidator *result = 0 ;
37577
37578 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37579 {
37580 PyThreadState* __tstate = wxPyBeginAllowThreads();
37581 result = (wxValidator *)new wxValidator();
37582 wxPyEndAllowThreads(__tstate);
37583 if (PyErr_Occurred()) SWIG_fail;
37584 }
37585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37586 return resultobj;
37587 fail:
37588 return NULL;
37589 }
37590
37591
37592 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37593 PyObject *resultobj = 0;
37594 wxValidator *arg1 = (wxValidator *) 0 ;
37595 wxValidator *result = 0 ;
37596 void *argp1 = 0 ;
37597 int res1 = 0 ;
37598 PyObject *swig_obj[1] ;
37599
37600 if (!args) SWIG_fail;
37601 swig_obj[0] = args;
37602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37603 if (!SWIG_IsOK(res1)) {
37604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37605 }
37606 arg1 = reinterpret_cast< wxValidator * >(argp1);
37607 {
37608 PyThreadState* __tstate = wxPyBeginAllowThreads();
37609 result = (wxValidator *)(arg1)->Clone();
37610 wxPyEndAllowThreads(__tstate);
37611 if (PyErr_Occurred()) SWIG_fail;
37612 }
37613 {
37614 resultobj = wxPyMake_wxObject(result, 0);
37615 }
37616 return resultobj;
37617 fail:
37618 return NULL;
37619 }
37620
37621
37622 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37623 PyObject *resultobj = 0;
37624 wxValidator *arg1 = (wxValidator *) 0 ;
37625 wxWindow *arg2 = (wxWindow *) 0 ;
37626 bool result;
37627 void *argp1 = 0 ;
37628 int res1 = 0 ;
37629 void *argp2 = 0 ;
37630 int res2 = 0 ;
37631 PyObject * obj0 = 0 ;
37632 PyObject * obj1 = 0 ;
37633 char * kwnames[] = {
37634 (char *) "self",(char *) "parent", NULL
37635 };
37636
37637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37639 if (!SWIG_IsOK(res1)) {
37640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37641 }
37642 arg1 = reinterpret_cast< wxValidator * >(argp1);
37643 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37644 if (!SWIG_IsOK(res2)) {
37645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37646 }
37647 arg2 = reinterpret_cast< wxWindow * >(argp2);
37648 {
37649 PyThreadState* __tstate = wxPyBeginAllowThreads();
37650 result = (bool)(arg1)->Validate(arg2);
37651 wxPyEndAllowThreads(__tstate);
37652 if (PyErr_Occurred()) SWIG_fail;
37653 }
37654 {
37655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37656 }
37657 return resultobj;
37658 fail:
37659 return NULL;
37660 }
37661
37662
37663 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37664 PyObject *resultobj = 0;
37665 wxValidator *arg1 = (wxValidator *) 0 ;
37666 bool result;
37667 void *argp1 = 0 ;
37668 int res1 = 0 ;
37669 PyObject *swig_obj[1] ;
37670
37671 if (!args) SWIG_fail;
37672 swig_obj[0] = args;
37673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37674 if (!SWIG_IsOK(res1)) {
37675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37676 }
37677 arg1 = reinterpret_cast< wxValidator * >(argp1);
37678 {
37679 PyThreadState* __tstate = wxPyBeginAllowThreads();
37680 result = (bool)(arg1)->TransferToWindow();
37681 wxPyEndAllowThreads(__tstate);
37682 if (PyErr_Occurred()) SWIG_fail;
37683 }
37684 {
37685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37686 }
37687 return resultobj;
37688 fail:
37689 return NULL;
37690 }
37691
37692
37693 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37694 PyObject *resultobj = 0;
37695 wxValidator *arg1 = (wxValidator *) 0 ;
37696 bool result;
37697 void *argp1 = 0 ;
37698 int res1 = 0 ;
37699 PyObject *swig_obj[1] ;
37700
37701 if (!args) SWIG_fail;
37702 swig_obj[0] = args;
37703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37704 if (!SWIG_IsOK(res1)) {
37705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37706 }
37707 arg1 = reinterpret_cast< wxValidator * >(argp1);
37708 {
37709 PyThreadState* __tstate = wxPyBeginAllowThreads();
37710 result = (bool)(arg1)->TransferFromWindow();
37711 wxPyEndAllowThreads(__tstate);
37712 if (PyErr_Occurred()) SWIG_fail;
37713 }
37714 {
37715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37716 }
37717 return resultobj;
37718 fail:
37719 return NULL;
37720 }
37721
37722
37723 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37724 PyObject *resultobj = 0;
37725 wxValidator *arg1 = (wxValidator *) 0 ;
37726 wxWindow *result = 0 ;
37727 void *argp1 = 0 ;
37728 int res1 = 0 ;
37729 PyObject *swig_obj[1] ;
37730
37731 if (!args) SWIG_fail;
37732 swig_obj[0] = args;
37733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37734 if (!SWIG_IsOK(res1)) {
37735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37736 }
37737 arg1 = reinterpret_cast< wxValidator * >(argp1);
37738 {
37739 PyThreadState* __tstate = wxPyBeginAllowThreads();
37740 result = (wxWindow *)(arg1)->GetWindow();
37741 wxPyEndAllowThreads(__tstate);
37742 if (PyErr_Occurred()) SWIG_fail;
37743 }
37744 {
37745 resultobj = wxPyMake_wxObject(result, 0);
37746 }
37747 return resultobj;
37748 fail:
37749 return NULL;
37750 }
37751
37752
37753 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37754 PyObject *resultobj = 0;
37755 wxValidator *arg1 = (wxValidator *) 0 ;
37756 wxWindow *arg2 = (wxWindow *) 0 ;
37757 void *argp1 = 0 ;
37758 int res1 = 0 ;
37759 void *argp2 = 0 ;
37760 int res2 = 0 ;
37761 PyObject * obj0 = 0 ;
37762 PyObject * obj1 = 0 ;
37763 char * kwnames[] = {
37764 (char *) "self",(char *) "window", NULL
37765 };
37766
37767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37769 if (!SWIG_IsOK(res1)) {
37770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37771 }
37772 arg1 = reinterpret_cast< wxValidator * >(argp1);
37773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37774 if (!SWIG_IsOK(res2)) {
37775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37776 }
37777 arg2 = reinterpret_cast< wxWindow * >(argp2);
37778 {
37779 PyThreadState* __tstate = wxPyBeginAllowThreads();
37780 (arg1)->SetWindow(arg2);
37781 wxPyEndAllowThreads(__tstate);
37782 if (PyErr_Occurred()) SWIG_fail;
37783 }
37784 resultobj = SWIG_Py_Void();
37785 return resultobj;
37786 fail:
37787 return NULL;
37788 }
37789
37790
37791 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37792 PyObject *resultobj = 0;
37793 bool result;
37794
37795 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37796 {
37797 PyThreadState* __tstate = wxPyBeginAllowThreads();
37798 result = (bool)wxValidator::IsSilent();
37799 wxPyEndAllowThreads(__tstate);
37800 if (PyErr_Occurred()) SWIG_fail;
37801 }
37802 {
37803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37804 }
37805 return resultobj;
37806 fail:
37807 return NULL;
37808 }
37809
37810
37811 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37812 PyObject *resultobj = 0;
37813 int arg1 = (int) true ;
37814 int val1 ;
37815 int ecode1 = 0 ;
37816 PyObject * obj0 = 0 ;
37817 char * kwnames[] = {
37818 (char *) "doIt", NULL
37819 };
37820
37821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37822 if (obj0) {
37823 ecode1 = SWIG_AsVal_int(obj0, &val1);
37824 if (!SWIG_IsOK(ecode1)) {
37825 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37826 }
37827 arg1 = static_cast< int >(val1);
37828 }
37829 {
37830 PyThreadState* __tstate = wxPyBeginAllowThreads();
37831 wxValidator::SetBellOnError(arg1);
37832 wxPyEndAllowThreads(__tstate);
37833 if (PyErr_Occurred()) SWIG_fail;
37834 }
37835 resultobj = SWIG_Py_Void();
37836 return resultobj;
37837 fail:
37838 return NULL;
37839 }
37840
37841
37842 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37843 PyObject *obj;
37844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37845 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37846 return SWIG_Py_Void();
37847 }
37848
37849 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37850 return SWIG_Python_InitShadowInstance(args);
37851 }
37852
37853 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37854 PyObject *resultobj = 0;
37855 wxPyValidator *result = 0 ;
37856
37857 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37858 {
37859 PyThreadState* __tstate = wxPyBeginAllowThreads();
37860 result = (wxPyValidator *)new wxPyValidator();
37861 wxPyEndAllowThreads(__tstate);
37862 if (PyErr_Occurred()) SWIG_fail;
37863 }
37864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37865 return resultobj;
37866 fail:
37867 return NULL;
37868 }
37869
37870
37871 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37872 PyObject *resultobj = 0;
37873 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37874 PyObject *arg2 = (PyObject *) 0 ;
37875 PyObject *arg3 = (PyObject *) 0 ;
37876 int arg4 = (int) true ;
37877 void *argp1 = 0 ;
37878 int res1 = 0 ;
37879 int val4 ;
37880 int ecode4 = 0 ;
37881 PyObject * obj0 = 0 ;
37882 PyObject * obj1 = 0 ;
37883 PyObject * obj2 = 0 ;
37884 PyObject * obj3 = 0 ;
37885 char * kwnames[] = {
37886 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37887 };
37888
37889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37891 if (!SWIG_IsOK(res1)) {
37892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37893 }
37894 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37895 arg2 = obj1;
37896 arg3 = obj2;
37897 if (obj3) {
37898 ecode4 = SWIG_AsVal_int(obj3, &val4);
37899 if (!SWIG_IsOK(ecode4)) {
37900 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37901 }
37902 arg4 = static_cast< int >(val4);
37903 }
37904 {
37905 PyThreadState* __tstate = wxPyBeginAllowThreads();
37906 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37907 wxPyEndAllowThreads(__tstate);
37908 if (PyErr_Occurred()) SWIG_fail;
37909 }
37910 resultobj = SWIG_Py_Void();
37911 return resultobj;
37912 fail:
37913 return NULL;
37914 }
37915
37916
37917 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37918 PyObject *obj;
37919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37920 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
37921 return SWIG_Py_Void();
37922 }
37923
37924 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37925 return SWIG_Python_InitShadowInstance(args);
37926 }
37927
37928 SWIGINTERN int DefaultValidator_set(PyObject *) {
37929 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
37930 return 1;
37931 }
37932
37933
37934 SWIGINTERN PyObject *DefaultValidator_get(void) {
37935 PyObject *pyobj = 0;
37936
37937 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
37938 return pyobj;
37939 }
37940
37941
37942 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37943 PyObject *resultobj = 0;
37944 wxString const &arg1_defvalue = wxPyEmptyString ;
37945 wxString *arg1 = (wxString *) &arg1_defvalue ;
37946 long arg2 = (long) 0 ;
37947 wxMenu *result = 0 ;
37948 bool temp1 = false ;
37949 long val2 ;
37950 int ecode2 = 0 ;
37951 PyObject * obj0 = 0 ;
37952 PyObject * obj1 = 0 ;
37953 char * kwnames[] = {
37954 (char *) "title",(char *) "style", NULL
37955 };
37956
37957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
37958 if (obj0) {
37959 {
37960 arg1 = wxString_in_helper(obj0);
37961 if (arg1 == NULL) SWIG_fail;
37962 temp1 = true;
37963 }
37964 }
37965 if (obj1) {
37966 ecode2 = SWIG_AsVal_long(obj1, &val2);
37967 if (!SWIG_IsOK(ecode2)) {
37968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
37969 }
37970 arg2 = static_cast< long >(val2);
37971 }
37972 {
37973 if (!wxPyCheckForApp()) SWIG_fail;
37974 PyThreadState* __tstate = wxPyBeginAllowThreads();
37975 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
37976 wxPyEndAllowThreads(__tstate);
37977 if (PyErr_Occurred()) SWIG_fail;
37978 }
37979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
37980 {
37981 if (temp1)
37982 delete arg1;
37983 }
37984 return resultobj;
37985 fail:
37986 {
37987 if (temp1)
37988 delete arg1;
37989 }
37990 return NULL;
37991 }
37992
37993
37994 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37995 PyObject *resultobj = 0;
37996 wxMenu *arg1 = (wxMenu *) 0 ;
37997 int arg2 ;
37998 wxString *arg3 = 0 ;
37999 wxString const &arg4_defvalue = wxPyEmptyString ;
38000 wxString *arg4 = (wxString *) &arg4_defvalue ;
38001 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38002 wxMenuItem *result = 0 ;
38003 void *argp1 = 0 ;
38004 int res1 = 0 ;
38005 int val2 ;
38006 int ecode2 = 0 ;
38007 bool temp3 = false ;
38008 bool temp4 = false ;
38009 int val5 ;
38010 int ecode5 = 0 ;
38011 PyObject * obj0 = 0 ;
38012 PyObject * obj1 = 0 ;
38013 PyObject * obj2 = 0 ;
38014 PyObject * obj3 = 0 ;
38015 PyObject * obj4 = 0 ;
38016 char * kwnames[] = {
38017 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38018 };
38019
38020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38022 if (!SWIG_IsOK(res1)) {
38023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38024 }
38025 arg1 = reinterpret_cast< wxMenu * >(argp1);
38026 ecode2 = SWIG_AsVal_int(obj1, &val2);
38027 if (!SWIG_IsOK(ecode2)) {
38028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38029 }
38030 arg2 = static_cast< int >(val2);
38031 {
38032 arg3 = wxString_in_helper(obj2);
38033 if (arg3 == NULL) SWIG_fail;
38034 temp3 = true;
38035 }
38036 if (obj3) {
38037 {
38038 arg4 = wxString_in_helper(obj3);
38039 if (arg4 == NULL) SWIG_fail;
38040 temp4 = true;
38041 }
38042 }
38043 if (obj4) {
38044 ecode5 = SWIG_AsVal_int(obj4, &val5);
38045 if (!SWIG_IsOK(ecode5)) {
38046 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38047 }
38048 arg5 = static_cast< wxItemKind >(val5);
38049 }
38050 {
38051 PyThreadState* __tstate = wxPyBeginAllowThreads();
38052 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38053 wxPyEndAllowThreads(__tstate);
38054 if (PyErr_Occurred()) SWIG_fail;
38055 }
38056 {
38057 resultobj = wxPyMake_wxObject(result, (bool)0);
38058 }
38059 {
38060 if (temp3)
38061 delete arg3;
38062 }
38063 {
38064 if (temp4)
38065 delete arg4;
38066 }
38067 return resultobj;
38068 fail:
38069 {
38070 if (temp3)
38071 delete arg3;
38072 }
38073 {
38074 if (temp4)
38075 delete arg4;
38076 }
38077 return NULL;
38078 }
38079
38080
38081 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38082 PyObject *resultobj = 0;
38083 wxMenu *arg1 = (wxMenu *) 0 ;
38084 wxMenuItem *result = 0 ;
38085 void *argp1 = 0 ;
38086 int res1 = 0 ;
38087 PyObject *swig_obj[1] ;
38088
38089 if (!args) SWIG_fail;
38090 swig_obj[0] = args;
38091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38092 if (!SWIG_IsOK(res1)) {
38093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38094 }
38095 arg1 = reinterpret_cast< wxMenu * >(argp1);
38096 {
38097 PyThreadState* __tstate = wxPyBeginAllowThreads();
38098 result = (wxMenuItem *)(arg1)->AppendSeparator();
38099 wxPyEndAllowThreads(__tstate);
38100 if (PyErr_Occurred()) SWIG_fail;
38101 }
38102 {
38103 resultobj = wxPyMake_wxObject(result, (bool)0);
38104 }
38105 return resultobj;
38106 fail:
38107 return NULL;
38108 }
38109
38110
38111 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38112 PyObject *resultobj = 0;
38113 wxMenu *arg1 = (wxMenu *) 0 ;
38114 int arg2 ;
38115 wxString *arg3 = 0 ;
38116 wxString const &arg4_defvalue = wxPyEmptyString ;
38117 wxString *arg4 = (wxString *) &arg4_defvalue ;
38118 wxMenuItem *result = 0 ;
38119 void *argp1 = 0 ;
38120 int res1 = 0 ;
38121 int val2 ;
38122 int ecode2 = 0 ;
38123 bool temp3 = false ;
38124 bool temp4 = false ;
38125 PyObject * obj0 = 0 ;
38126 PyObject * obj1 = 0 ;
38127 PyObject * obj2 = 0 ;
38128 PyObject * obj3 = 0 ;
38129 char * kwnames[] = {
38130 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38131 };
38132
38133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38135 if (!SWIG_IsOK(res1)) {
38136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38137 }
38138 arg1 = reinterpret_cast< wxMenu * >(argp1);
38139 ecode2 = SWIG_AsVal_int(obj1, &val2);
38140 if (!SWIG_IsOK(ecode2)) {
38141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38142 }
38143 arg2 = static_cast< int >(val2);
38144 {
38145 arg3 = wxString_in_helper(obj2);
38146 if (arg3 == NULL) SWIG_fail;
38147 temp3 = true;
38148 }
38149 if (obj3) {
38150 {
38151 arg4 = wxString_in_helper(obj3);
38152 if (arg4 == NULL) SWIG_fail;
38153 temp4 = true;
38154 }
38155 }
38156 {
38157 PyThreadState* __tstate = wxPyBeginAllowThreads();
38158 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38159 wxPyEndAllowThreads(__tstate);
38160 if (PyErr_Occurred()) SWIG_fail;
38161 }
38162 {
38163 resultobj = wxPyMake_wxObject(result, (bool)0);
38164 }
38165 {
38166 if (temp3)
38167 delete arg3;
38168 }
38169 {
38170 if (temp4)
38171 delete arg4;
38172 }
38173 return resultobj;
38174 fail:
38175 {
38176 if (temp3)
38177 delete arg3;
38178 }
38179 {
38180 if (temp4)
38181 delete arg4;
38182 }
38183 return NULL;
38184 }
38185
38186
38187 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38188 PyObject *resultobj = 0;
38189 wxMenu *arg1 = (wxMenu *) 0 ;
38190 int arg2 ;
38191 wxString *arg3 = 0 ;
38192 wxString const &arg4_defvalue = wxPyEmptyString ;
38193 wxString *arg4 = (wxString *) &arg4_defvalue ;
38194 wxMenuItem *result = 0 ;
38195 void *argp1 = 0 ;
38196 int res1 = 0 ;
38197 int val2 ;
38198 int ecode2 = 0 ;
38199 bool temp3 = false ;
38200 bool temp4 = false ;
38201 PyObject * obj0 = 0 ;
38202 PyObject * obj1 = 0 ;
38203 PyObject * obj2 = 0 ;
38204 PyObject * obj3 = 0 ;
38205 char * kwnames[] = {
38206 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38207 };
38208
38209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38211 if (!SWIG_IsOK(res1)) {
38212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38213 }
38214 arg1 = reinterpret_cast< wxMenu * >(argp1);
38215 ecode2 = SWIG_AsVal_int(obj1, &val2);
38216 if (!SWIG_IsOK(ecode2)) {
38217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38218 }
38219 arg2 = static_cast< int >(val2);
38220 {
38221 arg3 = wxString_in_helper(obj2);
38222 if (arg3 == NULL) SWIG_fail;
38223 temp3 = true;
38224 }
38225 if (obj3) {
38226 {
38227 arg4 = wxString_in_helper(obj3);
38228 if (arg4 == NULL) SWIG_fail;
38229 temp4 = true;
38230 }
38231 }
38232 {
38233 PyThreadState* __tstate = wxPyBeginAllowThreads();
38234 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38235 wxPyEndAllowThreads(__tstate);
38236 if (PyErr_Occurred()) SWIG_fail;
38237 }
38238 {
38239 resultobj = wxPyMake_wxObject(result, (bool)0);
38240 }
38241 {
38242 if (temp3)
38243 delete arg3;
38244 }
38245 {
38246 if (temp4)
38247 delete arg4;
38248 }
38249 return resultobj;
38250 fail:
38251 {
38252 if (temp3)
38253 delete arg3;
38254 }
38255 {
38256 if (temp4)
38257 delete arg4;
38258 }
38259 return NULL;
38260 }
38261
38262
38263 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38264 PyObject *resultobj = 0;
38265 wxMenu *arg1 = (wxMenu *) 0 ;
38266 int arg2 ;
38267 wxString *arg3 = 0 ;
38268 wxMenu *arg4 = (wxMenu *) 0 ;
38269 wxString const &arg5_defvalue = wxPyEmptyString ;
38270 wxString *arg5 = (wxString *) &arg5_defvalue ;
38271 wxMenuItem *result = 0 ;
38272 void *argp1 = 0 ;
38273 int res1 = 0 ;
38274 int val2 ;
38275 int ecode2 = 0 ;
38276 bool temp3 = false ;
38277 void *argp4 = 0 ;
38278 int res4 = 0 ;
38279 bool temp5 = false ;
38280 PyObject * obj0 = 0 ;
38281 PyObject * obj1 = 0 ;
38282 PyObject * obj2 = 0 ;
38283 PyObject * obj3 = 0 ;
38284 PyObject * obj4 = 0 ;
38285 char * kwnames[] = {
38286 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38287 };
38288
38289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38291 if (!SWIG_IsOK(res1)) {
38292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38293 }
38294 arg1 = reinterpret_cast< wxMenu * >(argp1);
38295 ecode2 = SWIG_AsVal_int(obj1, &val2);
38296 if (!SWIG_IsOK(ecode2)) {
38297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38298 }
38299 arg2 = static_cast< int >(val2);
38300 {
38301 arg3 = wxString_in_helper(obj2);
38302 if (arg3 == NULL) SWIG_fail;
38303 temp3 = true;
38304 }
38305 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38306 if (!SWIG_IsOK(res4)) {
38307 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38308 }
38309 arg4 = reinterpret_cast< wxMenu * >(argp4);
38310 if (obj4) {
38311 {
38312 arg5 = wxString_in_helper(obj4);
38313 if (arg5 == NULL) SWIG_fail;
38314 temp5 = true;
38315 }
38316 }
38317 {
38318 PyThreadState* __tstate = wxPyBeginAllowThreads();
38319 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38320 wxPyEndAllowThreads(__tstate);
38321 if (PyErr_Occurred()) SWIG_fail;
38322 }
38323 {
38324 resultobj = wxPyMake_wxObject(result, (bool)0);
38325 }
38326 {
38327 if (temp3)
38328 delete arg3;
38329 }
38330 {
38331 if (temp5)
38332 delete arg5;
38333 }
38334 return resultobj;
38335 fail:
38336 {
38337 if (temp3)
38338 delete arg3;
38339 }
38340 {
38341 if (temp5)
38342 delete arg5;
38343 }
38344 return NULL;
38345 }
38346
38347
38348 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38349 PyObject *resultobj = 0;
38350 wxMenu *arg1 = (wxMenu *) 0 ;
38351 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38352 wxMenuItem *result = 0 ;
38353 void *argp1 = 0 ;
38354 int res1 = 0 ;
38355 int res2 = 0 ;
38356 PyObject * obj0 = 0 ;
38357 PyObject * obj1 = 0 ;
38358 char * kwnames[] = {
38359 (char *) "self",(char *) "item", NULL
38360 };
38361
38362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38364 if (!SWIG_IsOK(res1)) {
38365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38366 }
38367 arg1 = reinterpret_cast< wxMenu * >(argp1);
38368 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38369 if (!SWIG_IsOK(res2)) {
38370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38371 }
38372 {
38373 PyThreadState* __tstate = wxPyBeginAllowThreads();
38374 result = (wxMenuItem *)(arg1)->Append(arg2);
38375 wxPyEndAllowThreads(__tstate);
38376 if (PyErr_Occurred()) SWIG_fail;
38377 }
38378 {
38379 resultobj = wxPyMake_wxObject(result, (bool)0);
38380 }
38381 return resultobj;
38382 fail:
38383 return NULL;
38384 }
38385
38386
38387 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38388 PyObject *resultobj = 0;
38389 wxMenu *arg1 = (wxMenu *) 0 ;
38390 size_t arg2 ;
38391 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38392 wxMenuItem *result = 0 ;
38393 void *argp1 = 0 ;
38394 int res1 = 0 ;
38395 size_t val2 ;
38396 int ecode2 = 0 ;
38397 int res3 = 0 ;
38398 PyObject * obj0 = 0 ;
38399 PyObject * obj1 = 0 ;
38400 PyObject * obj2 = 0 ;
38401 char * kwnames[] = {
38402 (char *) "self",(char *) "pos",(char *) "item", NULL
38403 };
38404
38405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38407 if (!SWIG_IsOK(res1)) {
38408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38409 }
38410 arg1 = reinterpret_cast< wxMenu * >(argp1);
38411 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38412 if (!SWIG_IsOK(ecode2)) {
38413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38414 }
38415 arg2 = static_cast< size_t >(val2);
38416 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38417 if (!SWIG_IsOK(res3)) {
38418 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38419 }
38420 {
38421 PyThreadState* __tstate = wxPyBeginAllowThreads();
38422 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38423 wxPyEndAllowThreads(__tstate);
38424 if (PyErr_Occurred()) SWIG_fail;
38425 }
38426 {
38427 resultobj = wxPyMake_wxObject(result, (bool)0);
38428 }
38429 return resultobj;
38430 fail:
38431 return NULL;
38432 }
38433
38434
38435 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38436 PyObject *resultobj = 0;
38437 wxMenu *arg1 = (wxMenu *) 0 ;
38438 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38439 wxMenuItem *result = 0 ;
38440 void *argp1 = 0 ;
38441 int res1 = 0 ;
38442 int res2 = 0 ;
38443 PyObject * obj0 = 0 ;
38444 PyObject * obj1 = 0 ;
38445 char * kwnames[] = {
38446 (char *) "self",(char *) "item", NULL
38447 };
38448
38449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38451 if (!SWIG_IsOK(res1)) {
38452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38453 }
38454 arg1 = reinterpret_cast< wxMenu * >(argp1);
38455 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38456 if (!SWIG_IsOK(res2)) {
38457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38458 }
38459 {
38460 PyThreadState* __tstate = wxPyBeginAllowThreads();
38461 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38462 wxPyEndAllowThreads(__tstate);
38463 if (PyErr_Occurred()) SWIG_fail;
38464 }
38465 {
38466 resultobj = wxPyMake_wxObject(result, (bool)0);
38467 }
38468 return resultobj;
38469 fail:
38470 return NULL;
38471 }
38472
38473
38474 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38475 PyObject *resultobj = 0;
38476 wxMenu *arg1 = (wxMenu *) 0 ;
38477 void *argp1 = 0 ;
38478 int res1 = 0 ;
38479 PyObject *swig_obj[1] ;
38480
38481 if (!args) SWIG_fail;
38482 swig_obj[0] = args;
38483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38484 if (!SWIG_IsOK(res1)) {
38485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38486 }
38487 arg1 = reinterpret_cast< wxMenu * >(argp1);
38488 {
38489 PyThreadState* __tstate = wxPyBeginAllowThreads();
38490 (arg1)->Break();
38491 wxPyEndAllowThreads(__tstate);
38492 if (PyErr_Occurred()) SWIG_fail;
38493 }
38494 resultobj = SWIG_Py_Void();
38495 return resultobj;
38496 fail:
38497 return NULL;
38498 }
38499
38500
38501 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38502 PyObject *resultobj = 0;
38503 wxMenu *arg1 = (wxMenu *) 0 ;
38504 size_t arg2 ;
38505 int arg3 ;
38506 wxString *arg4 = 0 ;
38507 wxString const &arg5_defvalue = wxPyEmptyString ;
38508 wxString *arg5 = (wxString *) &arg5_defvalue ;
38509 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38510 wxMenuItem *result = 0 ;
38511 void *argp1 = 0 ;
38512 int res1 = 0 ;
38513 size_t val2 ;
38514 int ecode2 = 0 ;
38515 int val3 ;
38516 int ecode3 = 0 ;
38517 bool temp4 = false ;
38518 bool temp5 = false ;
38519 int val6 ;
38520 int ecode6 = 0 ;
38521 PyObject * obj0 = 0 ;
38522 PyObject * obj1 = 0 ;
38523 PyObject * obj2 = 0 ;
38524 PyObject * obj3 = 0 ;
38525 PyObject * obj4 = 0 ;
38526 PyObject * obj5 = 0 ;
38527 char * kwnames[] = {
38528 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38529 };
38530
38531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38535 }
38536 arg1 = reinterpret_cast< wxMenu * >(argp1);
38537 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38538 if (!SWIG_IsOK(ecode2)) {
38539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38540 }
38541 arg2 = static_cast< size_t >(val2);
38542 ecode3 = SWIG_AsVal_int(obj2, &val3);
38543 if (!SWIG_IsOK(ecode3)) {
38544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38545 }
38546 arg3 = static_cast< int >(val3);
38547 {
38548 arg4 = wxString_in_helper(obj3);
38549 if (arg4 == NULL) SWIG_fail;
38550 temp4 = true;
38551 }
38552 if (obj4) {
38553 {
38554 arg5 = wxString_in_helper(obj4);
38555 if (arg5 == NULL) SWIG_fail;
38556 temp5 = true;
38557 }
38558 }
38559 if (obj5) {
38560 ecode6 = SWIG_AsVal_int(obj5, &val6);
38561 if (!SWIG_IsOK(ecode6)) {
38562 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38563 }
38564 arg6 = static_cast< wxItemKind >(val6);
38565 }
38566 {
38567 PyThreadState* __tstate = wxPyBeginAllowThreads();
38568 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38569 wxPyEndAllowThreads(__tstate);
38570 if (PyErr_Occurred()) SWIG_fail;
38571 }
38572 {
38573 resultobj = wxPyMake_wxObject(result, (bool)0);
38574 }
38575 {
38576 if (temp4)
38577 delete arg4;
38578 }
38579 {
38580 if (temp5)
38581 delete arg5;
38582 }
38583 return resultobj;
38584 fail:
38585 {
38586 if (temp4)
38587 delete arg4;
38588 }
38589 {
38590 if (temp5)
38591 delete arg5;
38592 }
38593 return NULL;
38594 }
38595
38596
38597 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38598 PyObject *resultobj = 0;
38599 wxMenu *arg1 = (wxMenu *) 0 ;
38600 size_t arg2 ;
38601 wxMenuItem *result = 0 ;
38602 void *argp1 = 0 ;
38603 int res1 = 0 ;
38604 size_t val2 ;
38605 int ecode2 = 0 ;
38606 PyObject * obj0 = 0 ;
38607 PyObject * obj1 = 0 ;
38608 char * kwnames[] = {
38609 (char *) "self",(char *) "pos", NULL
38610 };
38611
38612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38614 if (!SWIG_IsOK(res1)) {
38615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38616 }
38617 arg1 = reinterpret_cast< wxMenu * >(argp1);
38618 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38619 if (!SWIG_IsOK(ecode2)) {
38620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38621 }
38622 arg2 = static_cast< size_t >(val2);
38623 {
38624 PyThreadState* __tstate = wxPyBeginAllowThreads();
38625 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38626 wxPyEndAllowThreads(__tstate);
38627 if (PyErr_Occurred()) SWIG_fail;
38628 }
38629 {
38630 resultobj = wxPyMake_wxObject(result, (bool)0);
38631 }
38632 return resultobj;
38633 fail:
38634 return NULL;
38635 }
38636
38637
38638 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38639 PyObject *resultobj = 0;
38640 wxMenu *arg1 = (wxMenu *) 0 ;
38641 size_t arg2 ;
38642 int arg3 ;
38643 wxString *arg4 = 0 ;
38644 wxString const &arg5_defvalue = wxPyEmptyString ;
38645 wxString *arg5 = (wxString *) &arg5_defvalue ;
38646 wxMenuItem *result = 0 ;
38647 void *argp1 = 0 ;
38648 int res1 = 0 ;
38649 size_t val2 ;
38650 int ecode2 = 0 ;
38651 int val3 ;
38652 int ecode3 = 0 ;
38653 bool temp4 = false ;
38654 bool temp5 = false ;
38655 PyObject * obj0 = 0 ;
38656 PyObject * obj1 = 0 ;
38657 PyObject * obj2 = 0 ;
38658 PyObject * obj3 = 0 ;
38659 PyObject * obj4 = 0 ;
38660 char * kwnames[] = {
38661 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38662 };
38663
38664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38666 if (!SWIG_IsOK(res1)) {
38667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38668 }
38669 arg1 = reinterpret_cast< wxMenu * >(argp1);
38670 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38671 if (!SWIG_IsOK(ecode2)) {
38672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38673 }
38674 arg2 = static_cast< size_t >(val2);
38675 ecode3 = SWIG_AsVal_int(obj2, &val3);
38676 if (!SWIG_IsOK(ecode3)) {
38677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38678 }
38679 arg3 = static_cast< int >(val3);
38680 {
38681 arg4 = wxString_in_helper(obj3);
38682 if (arg4 == NULL) SWIG_fail;
38683 temp4 = true;
38684 }
38685 if (obj4) {
38686 {
38687 arg5 = wxString_in_helper(obj4);
38688 if (arg5 == NULL) SWIG_fail;
38689 temp5 = true;
38690 }
38691 }
38692 {
38693 PyThreadState* __tstate = wxPyBeginAllowThreads();
38694 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38695 wxPyEndAllowThreads(__tstate);
38696 if (PyErr_Occurred()) SWIG_fail;
38697 }
38698 {
38699 resultobj = wxPyMake_wxObject(result, (bool)0);
38700 }
38701 {
38702 if (temp4)
38703 delete arg4;
38704 }
38705 {
38706 if (temp5)
38707 delete arg5;
38708 }
38709 return resultobj;
38710 fail:
38711 {
38712 if (temp4)
38713 delete arg4;
38714 }
38715 {
38716 if (temp5)
38717 delete arg5;
38718 }
38719 return NULL;
38720 }
38721
38722
38723 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38724 PyObject *resultobj = 0;
38725 wxMenu *arg1 = (wxMenu *) 0 ;
38726 size_t arg2 ;
38727 int arg3 ;
38728 wxString *arg4 = 0 ;
38729 wxString const &arg5_defvalue = wxPyEmptyString ;
38730 wxString *arg5 = (wxString *) &arg5_defvalue ;
38731 wxMenuItem *result = 0 ;
38732 void *argp1 = 0 ;
38733 int res1 = 0 ;
38734 size_t val2 ;
38735 int ecode2 = 0 ;
38736 int val3 ;
38737 int ecode3 = 0 ;
38738 bool temp4 = false ;
38739 bool temp5 = false ;
38740 PyObject * obj0 = 0 ;
38741 PyObject * obj1 = 0 ;
38742 PyObject * obj2 = 0 ;
38743 PyObject * obj3 = 0 ;
38744 PyObject * obj4 = 0 ;
38745 char * kwnames[] = {
38746 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38747 };
38748
38749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38751 if (!SWIG_IsOK(res1)) {
38752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38753 }
38754 arg1 = reinterpret_cast< wxMenu * >(argp1);
38755 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38756 if (!SWIG_IsOK(ecode2)) {
38757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38758 }
38759 arg2 = static_cast< size_t >(val2);
38760 ecode3 = SWIG_AsVal_int(obj2, &val3);
38761 if (!SWIG_IsOK(ecode3)) {
38762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38763 }
38764 arg3 = static_cast< int >(val3);
38765 {
38766 arg4 = wxString_in_helper(obj3);
38767 if (arg4 == NULL) SWIG_fail;
38768 temp4 = true;
38769 }
38770 if (obj4) {
38771 {
38772 arg5 = wxString_in_helper(obj4);
38773 if (arg5 == NULL) SWIG_fail;
38774 temp5 = true;
38775 }
38776 }
38777 {
38778 PyThreadState* __tstate = wxPyBeginAllowThreads();
38779 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38780 wxPyEndAllowThreads(__tstate);
38781 if (PyErr_Occurred()) SWIG_fail;
38782 }
38783 {
38784 resultobj = wxPyMake_wxObject(result, (bool)0);
38785 }
38786 {
38787 if (temp4)
38788 delete arg4;
38789 }
38790 {
38791 if (temp5)
38792 delete arg5;
38793 }
38794 return resultobj;
38795 fail:
38796 {
38797 if (temp4)
38798 delete arg4;
38799 }
38800 {
38801 if (temp5)
38802 delete arg5;
38803 }
38804 return NULL;
38805 }
38806
38807
38808 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38809 PyObject *resultobj = 0;
38810 wxMenu *arg1 = (wxMenu *) 0 ;
38811 size_t arg2 ;
38812 int arg3 ;
38813 wxString *arg4 = 0 ;
38814 wxMenu *arg5 = (wxMenu *) 0 ;
38815 wxString const &arg6_defvalue = wxPyEmptyString ;
38816 wxString *arg6 = (wxString *) &arg6_defvalue ;
38817 wxMenuItem *result = 0 ;
38818 void *argp1 = 0 ;
38819 int res1 = 0 ;
38820 size_t val2 ;
38821 int ecode2 = 0 ;
38822 int val3 ;
38823 int ecode3 = 0 ;
38824 bool temp4 = false ;
38825 void *argp5 = 0 ;
38826 int res5 = 0 ;
38827 bool temp6 = false ;
38828 PyObject * obj0 = 0 ;
38829 PyObject * obj1 = 0 ;
38830 PyObject * obj2 = 0 ;
38831 PyObject * obj3 = 0 ;
38832 PyObject * obj4 = 0 ;
38833 PyObject * obj5 = 0 ;
38834 char * kwnames[] = {
38835 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38836 };
38837
38838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38840 if (!SWIG_IsOK(res1)) {
38841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38842 }
38843 arg1 = reinterpret_cast< wxMenu * >(argp1);
38844 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38845 if (!SWIG_IsOK(ecode2)) {
38846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38847 }
38848 arg2 = static_cast< size_t >(val2);
38849 ecode3 = SWIG_AsVal_int(obj2, &val3);
38850 if (!SWIG_IsOK(ecode3)) {
38851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38852 }
38853 arg3 = static_cast< int >(val3);
38854 {
38855 arg4 = wxString_in_helper(obj3);
38856 if (arg4 == NULL) SWIG_fail;
38857 temp4 = true;
38858 }
38859 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
38860 if (!SWIG_IsOK(res5)) {
38861 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
38862 }
38863 arg5 = reinterpret_cast< wxMenu * >(argp5);
38864 if (obj5) {
38865 {
38866 arg6 = wxString_in_helper(obj5);
38867 if (arg6 == NULL) SWIG_fail;
38868 temp6 = true;
38869 }
38870 }
38871 {
38872 PyThreadState* __tstate = wxPyBeginAllowThreads();
38873 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
38874 wxPyEndAllowThreads(__tstate);
38875 if (PyErr_Occurred()) SWIG_fail;
38876 }
38877 {
38878 resultobj = wxPyMake_wxObject(result, (bool)0);
38879 }
38880 {
38881 if (temp4)
38882 delete arg4;
38883 }
38884 {
38885 if (temp6)
38886 delete arg6;
38887 }
38888 return resultobj;
38889 fail:
38890 {
38891 if (temp4)
38892 delete arg4;
38893 }
38894 {
38895 if (temp6)
38896 delete arg6;
38897 }
38898 return NULL;
38899 }
38900
38901
38902 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38903 PyObject *resultobj = 0;
38904 wxMenu *arg1 = (wxMenu *) 0 ;
38905 int arg2 ;
38906 wxString *arg3 = 0 ;
38907 wxString const &arg4_defvalue = wxPyEmptyString ;
38908 wxString *arg4 = (wxString *) &arg4_defvalue ;
38909 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38910 wxMenuItem *result = 0 ;
38911 void *argp1 = 0 ;
38912 int res1 = 0 ;
38913 int val2 ;
38914 int ecode2 = 0 ;
38915 bool temp3 = false ;
38916 bool temp4 = false ;
38917 int val5 ;
38918 int ecode5 = 0 ;
38919 PyObject * obj0 = 0 ;
38920 PyObject * obj1 = 0 ;
38921 PyObject * obj2 = 0 ;
38922 PyObject * obj3 = 0 ;
38923 PyObject * obj4 = 0 ;
38924 char * kwnames[] = {
38925 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38926 };
38927
38928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38930 if (!SWIG_IsOK(res1)) {
38931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
38932 }
38933 arg1 = reinterpret_cast< wxMenu * >(argp1);
38934 ecode2 = SWIG_AsVal_int(obj1, &val2);
38935 if (!SWIG_IsOK(ecode2)) {
38936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
38937 }
38938 arg2 = static_cast< int >(val2);
38939 {
38940 arg3 = wxString_in_helper(obj2);
38941 if (arg3 == NULL) SWIG_fail;
38942 temp3 = true;
38943 }
38944 if (obj3) {
38945 {
38946 arg4 = wxString_in_helper(obj3);
38947 if (arg4 == NULL) SWIG_fail;
38948 temp4 = true;
38949 }
38950 }
38951 if (obj4) {
38952 ecode5 = SWIG_AsVal_int(obj4, &val5);
38953 if (!SWIG_IsOK(ecode5)) {
38954 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
38955 }
38956 arg5 = static_cast< wxItemKind >(val5);
38957 }
38958 {
38959 PyThreadState* __tstate = wxPyBeginAllowThreads();
38960 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38961 wxPyEndAllowThreads(__tstate);
38962 if (PyErr_Occurred()) SWIG_fail;
38963 }
38964 {
38965 resultobj = wxPyMake_wxObject(result, (bool)0);
38966 }
38967 {
38968 if (temp3)
38969 delete arg3;
38970 }
38971 {
38972 if (temp4)
38973 delete arg4;
38974 }
38975 return resultobj;
38976 fail:
38977 {
38978 if (temp3)
38979 delete arg3;
38980 }
38981 {
38982 if (temp4)
38983 delete arg4;
38984 }
38985 return NULL;
38986 }
38987
38988
38989 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38990 PyObject *resultobj = 0;
38991 wxMenu *arg1 = (wxMenu *) 0 ;
38992 wxMenuItem *result = 0 ;
38993 void *argp1 = 0 ;
38994 int res1 = 0 ;
38995 PyObject *swig_obj[1] ;
38996
38997 if (!args) SWIG_fail;
38998 swig_obj[0] = args;
38999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39000 if (!SWIG_IsOK(res1)) {
39001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39002 }
39003 arg1 = reinterpret_cast< wxMenu * >(argp1);
39004 {
39005 PyThreadState* __tstate = wxPyBeginAllowThreads();
39006 result = (wxMenuItem *)(arg1)->PrependSeparator();
39007 wxPyEndAllowThreads(__tstate);
39008 if (PyErr_Occurred()) SWIG_fail;
39009 }
39010 {
39011 resultobj = wxPyMake_wxObject(result, (bool)0);
39012 }
39013 return resultobj;
39014 fail:
39015 return NULL;
39016 }
39017
39018
39019 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39020 PyObject *resultobj = 0;
39021 wxMenu *arg1 = (wxMenu *) 0 ;
39022 int arg2 ;
39023 wxString *arg3 = 0 ;
39024 wxString const &arg4_defvalue = wxPyEmptyString ;
39025 wxString *arg4 = (wxString *) &arg4_defvalue ;
39026 wxMenuItem *result = 0 ;
39027 void *argp1 = 0 ;
39028 int res1 = 0 ;
39029 int val2 ;
39030 int ecode2 = 0 ;
39031 bool temp3 = false ;
39032 bool temp4 = false ;
39033 PyObject * obj0 = 0 ;
39034 PyObject * obj1 = 0 ;
39035 PyObject * obj2 = 0 ;
39036 PyObject * obj3 = 0 ;
39037 char * kwnames[] = {
39038 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39039 };
39040
39041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39043 if (!SWIG_IsOK(res1)) {
39044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39045 }
39046 arg1 = reinterpret_cast< wxMenu * >(argp1);
39047 ecode2 = SWIG_AsVal_int(obj1, &val2);
39048 if (!SWIG_IsOK(ecode2)) {
39049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39050 }
39051 arg2 = static_cast< int >(val2);
39052 {
39053 arg3 = wxString_in_helper(obj2);
39054 if (arg3 == NULL) SWIG_fail;
39055 temp3 = true;
39056 }
39057 if (obj3) {
39058 {
39059 arg4 = wxString_in_helper(obj3);
39060 if (arg4 == NULL) SWIG_fail;
39061 temp4 = true;
39062 }
39063 }
39064 {
39065 PyThreadState* __tstate = wxPyBeginAllowThreads();
39066 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39067 wxPyEndAllowThreads(__tstate);
39068 if (PyErr_Occurred()) SWIG_fail;
39069 }
39070 {
39071 resultobj = wxPyMake_wxObject(result, (bool)0);
39072 }
39073 {
39074 if (temp3)
39075 delete arg3;
39076 }
39077 {
39078 if (temp4)
39079 delete arg4;
39080 }
39081 return resultobj;
39082 fail:
39083 {
39084 if (temp3)
39085 delete arg3;
39086 }
39087 {
39088 if (temp4)
39089 delete arg4;
39090 }
39091 return NULL;
39092 }
39093
39094
39095 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39096 PyObject *resultobj = 0;
39097 wxMenu *arg1 = (wxMenu *) 0 ;
39098 int arg2 ;
39099 wxString *arg3 = 0 ;
39100 wxString const &arg4_defvalue = wxPyEmptyString ;
39101 wxString *arg4 = (wxString *) &arg4_defvalue ;
39102 wxMenuItem *result = 0 ;
39103 void *argp1 = 0 ;
39104 int res1 = 0 ;
39105 int val2 ;
39106 int ecode2 = 0 ;
39107 bool temp3 = false ;
39108 bool temp4 = false ;
39109 PyObject * obj0 = 0 ;
39110 PyObject * obj1 = 0 ;
39111 PyObject * obj2 = 0 ;
39112 PyObject * obj3 = 0 ;
39113 char * kwnames[] = {
39114 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39115 };
39116
39117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39119 if (!SWIG_IsOK(res1)) {
39120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39121 }
39122 arg1 = reinterpret_cast< wxMenu * >(argp1);
39123 ecode2 = SWIG_AsVal_int(obj1, &val2);
39124 if (!SWIG_IsOK(ecode2)) {
39125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39126 }
39127 arg2 = static_cast< int >(val2);
39128 {
39129 arg3 = wxString_in_helper(obj2);
39130 if (arg3 == NULL) SWIG_fail;
39131 temp3 = true;
39132 }
39133 if (obj3) {
39134 {
39135 arg4 = wxString_in_helper(obj3);
39136 if (arg4 == NULL) SWIG_fail;
39137 temp4 = true;
39138 }
39139 }
39140 {
39141 PyThreadState* __tstate = wxPyBeginAllowThreads();
39142 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39143 wxPyEndAllowThreads(__tstate);
39144 if (PyErr_Occurred()) SWIG_fail;
39145 }
39146 {
39147 resultobj = wxPyMake_wxObject(result, (bool)0);
39148 }
39149 {
39150 if (temp3)
39151 delete arg3;
39152 }
39153 {
39154 if (temp4)
39155 delete arg4;
39156 }
39157 return resultobj;
39158 fail:
39159 {
39160 if (temp3)
39161 delete arg3;
39162 }
39163 {
39164 if (temp4)
39165 delete arg4;
39166 }
39167 return NULL;
39168 }
39169
39170
39171 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39172 PyObject *resultobj = 0;
39173 wxMenu *arg1 = (wxMenu *) 0 ;
39174 int arg2 ;
39175 wxString *arg3 = 0 ;
39176 wxMenu *arg4 = (wxMenu *) 0 ;
39177 wxString const &arg5_defvalue = wxPyEmptyString ;
39178 wxString *arg5 = (wxString *) &arg5_defvalue ;
39179 wxMenuItem *result = 0 ;
39180 void *argp1 = 0 ;
39181 int res1 = 0 ;
39182 int val2 ;
39183 int ecode2 = 0 ;
39184 bool temp3 = false ;
39185 void *argp4 = 0 ;
39186 int res4 = 0 ;
39187 bool temp5 = false ;
39188 PyObject * obj0 = 0 ;
39189 PyObject * obj1 = 0 ;
39190 PyObject * obj2 = 0 ;
39191 PyObject * obj3 = 0 ;
39192 PyObject * obj4 = 0 ;
39193 char * kwnames[] = {
39194 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39195 };
39196
39197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39199 if (!SWIG_IsOK(res1)) {
39200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39201 }
39202 arg1 = reinterpret_cast< wxMenu * >(argp1);
39203 ecode2 = SWIG_AsVal_int(obj1, &val2);
39204 if (!SWIG_IsOK(ecode2)) {
39205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39206 }
39207 arg2 = static_cast< int >(val2);
39208 {
39209 arg3 = wxString_in_helper(obj2);
39210 if (arg3 == NULL) SWIG_fail;
39211 temp3 = true;
39212 }
39213 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39214 if (!SWIG_IsOK(res4)) {
39215 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39216 }
39217 arg4 = reinterpret_cast< wxMenu * >(argp4);
39218 if (obj4) {
39219 {
39220 arg5 = wxString_in_helper(obj4);
39221 if (arg5 == NULL) SWIG_fail;
39222 temp5 = true;
39223 }
39224 }
39225 {
39226 PyThreadState* __tstate = wxPyBeginAllowThreads();
39227 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39228 wxPyEndAllowThreads(__tstate);
39229 if (PyErr_Occurred()) SWIG_fail;
39230 }
39231 {
39232 resultobj = wxPyMake_wxObject(result, (bool)0);
39233 }
39234 {
39235 if (temp3)
39236 delete arg3;
39237 }
39238 {
39239 if (temp5)
39240 delete arg5;
39241 }
39242 return resultobj;
39243 fail:
39244 {
39245 if (temp3)
39246 delete arg3;
39247 }
39248 {
39249 if (temp5)
39250 delete arg5;
39251 }
39252 return NULL;
39253 }
39254
39255
39256 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39257 PyObject *resultobj = 0;
39258 wxMenu *arg1 = (wxMenu *) 0 ;
39259 int arg2 ;
39260 wxMenuItem *result = 0 ;
39261 void *argp1 = 0 ;
39262 int res1 = 0 ;
39263 int val2 ;
39264 int ecode2 = 0 ;
39265 PyObject * obj0 = 0 ;
39266 PyObject * obj1 = 0 ;
39267 char * kwnames[] = {
39268 (char *) "self",(char *) "id", NULL
39269 };
39270
39271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39273 if (!SWIG_IsOK(res1)) {
39274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39275 }
39276 arg1 = reinterpret_cast< wxMenu * >(argp1);
39277 ecode2 = SWIG_AsVal_int(obj1, &val2);
39278 if (!SWIG_IsOK(ecode2)) {
39279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39280 }
39281 arg2 = static_cast< int >(val2);
39282 {
39283 PyThreadState* __tstate = wxPyBeginAllowThreads();
39284 result = (wxMenuItem *)(arg1)->Remove(arg2);
39285 wxPyEndAllowThreads(__tstate);
39286 if (PyErr_Occurred()) SWIG_fail;
39287 }
39288 {
39289 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39290 }
39291 return resultobj;
39292 fail:
39293 return NULL;
39294 }
39295
39296
39297 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39298 PyObject *resultobj = 0;
39299 wxMenu *arg1 = (wxMenu *) 0 ;
39300 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39301 wxMenuItem *result = 0 ;
39302 void *argp1 = 0 ;
39303 int res1 = 0 ;
39304 void *argp2 = 0 ;
39305 int res2 = 0 ;
39306 PyObject * obj0 = 0 ;
39307 PyObject * obj1 = 0 ;
39308 char * kwnames[] = {
39309 (char *) "self",(char *) "item", NULL
39310 };
39311
39312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39314 if (!SWIG_IsOK(res1)) {
39315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39316 }
39317 arg1 = reinterpret_cast< wxMenu * >(argp1);
39318 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39319 if (!SWIG_IsOK(res2)) {
39320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39321 }
39322 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39323 {
39324 PyThreadState* __tstate = wxPyBeginAllowThreads();
39325 result = (wxMenuItem *)(arg1)->Remove(arg2);
39326 wxPyEndAllowThreads(__tstate);
39327 if (PyErr_Occurred()) SWIG_fail;
39328 }
39329 {
39330 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39331 }
39332 return resultobj;
39333 fail:
39334 return NULL;
39335 }
39336
39337
39338 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39339 PyObject *resultobj = 0;
39340 wxMenu *arg1 = (wxMenu *) 0 ;
39341 int arg2 ;
39342 bool result;
39343 void *argp1 = 0 ;
39344 int res1 = 0 ;
39345 int val2 ;
39346 int ecode2 = 0 ;
39347 PyObject * obj0 = 0 ;
39348 PyObject * obj1 = 0 ;
39349 char * kwnames[] = {
39350 (char *) "self",(char *) "id", NULL
39351 };
39352
39353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39355 if (!SWIG_IsOK(res1)) {
39356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39357 }
39358 arg1 = reinterpret_cast< wxMenu * >(argp1);
39359 ecode2 = SWIG_AsVal_int(obj1, &val2);
39360 if (!SWIG_IsOK(ecode2)) {
39361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39362 }
39363 arg2 = static_cast< int >(val2);
39364 {
39365 PyThreadState* __tstate = wxPyBeginAllowThreads();
39366 result = (bool)(arg1)->Delete(arg2);
39367 wxPyEndAllowThreads(__tstate);
39368 if (PyErr_Occurred()) SWIG_fail;
39369 }
39370 {
39371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39372 }
39373 return resultobj;
39374 fail:
39375 return NULL;
39376 }
39377
39378
39379 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39380 PyObject *resultobj = 0;
39381 wxMenu *arg1 = (wxMenu *) 0 ;
39382 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39383 bool result;
39384 void *argp1 = 0 ;
39385 int res1 = 0 ;
39386 void *argp2 = 0 ;
39387 int res2 = 0 ;
39388 PyObject * obj0 = 0 ;
39389 PyObject * obj1 = 0 ;
39390 char * kwnames[] = {
39391 (char *) "self",(char *) "item", NULL
39392 };
39393
39394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39396 if (!SWIG_IsOK(res1)) {
39397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39398 }
39399 arg1 = reinterpret_cast< wxMenu * >(argp1);
39400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39401 if (!SWIG_IsOK(res2)) {
39402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39403 }
39404 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39405 {
39406 PyThreadState* __tstate = wxPyBeginAllowThreads();
39407 result = (bool)(arg1)->Delete(arg2);
39408 wxPyEndAllowThreads(__tstate);
39409 if (PyErr_Occurred()) SWIG_fail;
39410 }
39411 {
39412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39413 }
39414 return resultobj;
39415 fail:
39416 return NULL;
39417 }
39418
39419
39420 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39421 PyObject *resultobj = 0;
39422 wxMenu *arg1 = (wxMenu *) 0 ;
39423 void *argp1 = 0 ;
39424 int res1 = 0 ;
39425 PyObject *swig_obj[1] ;
39426
39427 if (!args) SWIG_fail;
39428 swig_obj[0] = args;
39429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39430 if (!SWIG_IsOK(res1)) {
39431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39432 }
39433 arg1 = reinterpret_cast< wxMenu * >(argp1);
39434 {
39435 PyThreadState* __tstate = wxPyBeginAllowThreads();
39436 wxMenu_Destroy(arg1);
39437 wxPyEndAllowThreads(__tstate);
39438 if (PyErr_Occurred()) SWIG_fail;
39439 }
39440 resultobj = SWIG_Py_Void();
39441 return resultobj;
39442 fail:
39443 return NULL;
39444 }
39445
39446
39447 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39448 PyObject *resultobj = 0;
39449 wxMenu *arg1 = (wxMenu *) 0 ;
39450 int arg2 ;
39451 bool result;
39452 void *argp1 = 0 ;
39453 int res1 = 0 ;
39454 int val2 ;
39455 int ecode2 = 0 ;
39456 PyObject * obj0 = 0 ;
39457 PyObject * obj1 = 0 ;
39458 char * kwnames[] = {
39459 (char *) "self",(char *) "id", NULL
39460 };
39461
39462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39464 if (!SWIG_IsOK(res1)) {
39465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39466 }
39467 arg1 = reinterpret_cast< wxMenu * >(argp1);
39468 ecode2 = SWIG_AsVal_int(obj1, &val2);
39469 if (!SWIG_IsOK(ecode2)) {
39470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39471 }
39472 arg2 = static_cast< int >(val2);
39473 {
39474 PyThreadState* __tstate = wxPyBeginAllowThreads();
39475 result = (bool)(arg1)->Destroy(arg2);
39476 wxPyEndAllowThreads(__tstate);
39477 if (PyErr_Occurred()) SWIG_fail;
39478 }
39479 {
39480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39481 }
39482 return resultobj;
39483 fail:
39484 return NULL;
39485 }
39486
39487
39488 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39489 PyObject *resultobj = 0;
39490 wxMenu *arg1 = (wxMenu *) 0 ;
39491 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39492 bool result;
39493 void *argp1 = 0 ;
39494 int res1 = 0 ;
39495 void *argp2 = 0 ;
39496 int res2 = 0 ;
39497 PyObject * obj0 = 0 ;
39498 PyObject * obj1 = 0 ;
39499 char * kwnames[] = {
39500 (char *) "self",(char *) "item", NULL
39501 };
39502
39503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39505 if (!SWIG_IsOK(res1)) {
39506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39507 }
39508 arg1 = reinterpret_cast< wxMenu * >(argp1);
39509 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39510 if (!SWIG_IsOK(res2)) {
39511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39512 }
39513 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39514 {
39515 PyThreadState* __tstate = wxPyBeginAllowThreads();
39516 result = (bool)(arg1)->Destroy(arg2);
39517 wxPyEndAllowThreads(__tstate);
39518 if (PyErr_Occurred()) SWIG_fail;
39519 }
39520 {
39521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39522 }
39523 return resultobj;
39524 fail:
39525 return NULL;
39526 }
39527
39528
39529 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39530 PyObject *resultobj = 0;
39531 wxMenu *arg1 = (wxMenu *) 0 ;
39532 size_t result;
39533 void *argp1 = 0 ;
39534 int res1 = 0 ;
39535 PyObject *swig_obj[1] ;
39536
39537 if (!args) SWIG_fail;
39538 swig_obj[0] = args;
39539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39540 if (!SWIG_IsOK(res1)) {
39541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39542 }
39543 arg1 = reinterpret_cast< wxMenu * >(argp1);
39544 {
39545 PyThreadState* __tstate = wxPyBeginAllowThreads();
39546 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39547 wxPyEndAllowThreads(__tstate);
39548 if (PyErr_Occurred()) SWIG_fail;
39549 }
39550 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39551 return resultobj;
39552 fail:
39553 return NULL;
39554 }
39555
39556
39557 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39558 PyObject *resultobj = 0;
39559 wxMenu *arg1 = (wxMenu *) 0 ;
39560 PyObject *result = 0 ;
39561 void *argp1 = 0 ;
39562 int res1 = 0 ;
39563 PyObject *swig_obj[1] ;
39564
39565 if (!args) SWIG_fail;
39566 swig_obj[0] = args;
39567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39568 if (!SWIG_IsOK(res1)) {
39569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39570 }
39571 arg1 = reinterpret_cast< wxMenu * >(argp1);
39572 {
39573 PyThreadState* __tstate = wxPyBeginAllowThreads();
39574 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39575 wxPyEndAllowThreads(__tstate);
39576 if (PyErr_Occurred()) SWIG_fail;
39577 }
39578 resultobj = result;
39579 return resultobj;
39580 fail:
39581 return NULL;
39582 }
39583
39584
39585 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39586 PyObject *resultobj = 0;
39587 wxMenu *arg1 = (wxMenu *) 0 ;
39588 wxString *arg2 = 0 ;
39589 int result;
39590 void *argp1 = 0 ;
39591 int res1 = 0 ;
39592 bool temp2 = false ;
39593 PyObject * obj0 = 0 ;
39594 PyObject * obj1 = 0 ;
39595 char * kwnames[] = {
39596 (char *) "self",(char *) "item", NULL
39597 };
39598
39599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39601 if (!SWIG_IsOK(res1)) {
39602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39603 }
39604 arg1 = reinterpret_cast< wxMenu * >(argp1);
39605 {
39606 arg2 = wxString_in_helper(obj1);
39607 if (arg2 == NULL) SWIG_fail;
39608 temp2 = true;
39609 }
39610 {
39611 PyThreadState* __tstate = wxPyBeginAllowThreads();
39612 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39613 wxPyEndAllowThreads(__tstate);
39614 if (PyErr_Occurred()) SWIG_fail;
39615 }
39616 resultobj = SWIG_From_int(static_cast< int >(result));
39617 {
39618 if (temp2)
39619 delete arg2;
39620 }
39621 return resultobj;
39622 fail:
39623 {
39624 if (temp2)
39625 delete arg2;
39626 }
39627 return NULL;
39628 }
39629
39630
39631 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39632 PyObject *resultobj = 0;
39633 wxMenu *arg1 = (wxMenu *) 0 ;
39634 int arg2 ;
39635 wxMenuItem *result = 0 ;
39636 void *argp1 = 0 ;
39637 int res1 = 0 ;
39638 int val2 ;
39639 int ecode2 = 0 ;
39640 PyObject * obj0 = 0 ;
39641 PyObject * obj1 = 0 ;
39642 char * kwnames[] = {
39643 (char *) "self",(char *) "id", NULL
39644 };
39645
39646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39648 if (!SWIG_IsOK(res1)) {
39649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39650 }
39651 arg1 = reinterpret_cast< wxMenu * >(argp1);
39652 ecode2 = SWIG_AsVal_int(obj1, &val2);
39653 if (!SWIG_IsOK(ecode2)) {
39654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39655 }
39656 arg2 = static_cast< int >(val2);
39657 {
39658 PyThreadState* __tstate = wxPyBeginAllowThreads();
39659 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39660 wxPyEndAllowThreads(__tstate);
39661 if (PyErr_Occurred()) SWIG_fail;
39662 }
39663 {
39664 resultobj = wxPyMake_wxObject(result, (bool)0);
39665 }
39666 return resultobj;
39667 fail:
39668 return NULL;
39669 }
39670
39671
39672 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39673 PyObject *resultobj = 0;
39674 wxMenu *arg1 = (wxMenu *) 0 ;
39675 size_t arg2 ;
39676 wxMenuItem *result = 0 ;
39677 void *argp1 = 0 ;
39678 int res1 = 0 ;
39679 size_t val2 ;
39680 int ecode2 = 0 ;
39681 PyObject * obj0 = 0 ;
39682 PyObject * obj1 = 0 ;
39683 char * kwnames[] = {
39684 (char *) "self",(char *) "position", NULL
39685 };
39686
39687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39689 if (!SWIG_IsOK(res1)) {
39690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39691 }
39692 arg1 = reinterpret_cast< wxMenu * >(argp1);
39693 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39694 if (!SWIG_IsOK(ecode2)) {
39695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39696 }
39697 arg2 = static_cast< size_t >(val2);
39698 {
39699 PyThreadState* __tstate = wxPyBeginAllowThreads();
39700 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39701 wxPyEndAllowThreads(__tstate);
39702 if (PyErr_Occurred()) SWIG_fail;
39703 }
39704 {
39705 resultobj = wxPyMake_wxObject(result, (bool)0);
39706 }
39707 return resultobj;
39708 fail:
39709 return NULL;
39710 }
39711
39712
39713 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39714 PyObject *resultobj = 0;
39715 wxMenu *arg1 = (wxMenu *) 0 ;
39716 int arg2 ;
39717 bool arg3 ;
39718 void *argp1 = 0 ;
39719 int res1 = 0 ;
39720 int val2 ;
39721 int ecode2 = 0 ;
39722 bool val3 ;
39723 int ecode3 = 0 ;
39724 PyObject * obj0 = 0 ;
39725 PyObject * obj1 = 0 ;
39726 PyObject * obj2 = 0 ;
39727 char * kwnames[] = {
39728 (char *) "self",(char *) "id",(char *) "enable", NULL
39729 };
39730
39731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39733 if (!SWIG_IsOK(res1)) {
39734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39735 }
39736 arg1 = reinterpret_cast< wxMenu * >(argp1);
39737 ecode2 = SWIG_AsVal_int(obj1, &val2);
39738 if (!SWIG_IsOK(ecode2)) {
39739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39740 }
39741 arg2 = static_cast< int >(val2);
39742 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39743 if (!SWIG_IsOK(ecode3)) {
39744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39745 }
39746 arg3 = static_cast< bool >(val3);
39747 {
39748 PyThreadState* __tstate = wxPyBeginAllowThreads();
39749 (arg1)->Enable(arg2,arg3);
39750 wxPyEndAllowThreads(__tstate);
39751 if (PyErr_Occurred()) SWIG_fail;
39752 }
39753 resultobj = SWIG_Py_Void();
39754 return resultobj;
39755 fail:
39756 return NULL;
39757 }
39758
39759
39760 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39761 PyObject *resultobj = 0;
39762 wxMenu *arg1 = (wxMenu *) 0 ;
39763 int arg2 ;
39764 bool result;
39765 void *argp1 = 0 ;
39766 int res1 = 0 ;
39767 int val2 ;
39768 int ecode2 = 0 ;
39769 PyObject * obj0 = 0 ;
39770 PyObject * obj1 = 0 ;
39771 char * kwnames[] = {
39772 (char *) "self",(char *) "id", NULL
39773 };
39774
39775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39777 if (!SWIG_IsOK(res1)) {
39778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39779 }
39780 arg1 = reinterpret_cast< wxMenu * >(argp1);
39781 ecode2 = SWIG_AsVal_int(obj1, &val2);
39782 if (!SWIG_IsOK(ecode2)) {
39783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39784 }
39785 arg2 = static_cast< int >(val2);
39786 {
39787 PyThreadState* __tstate = wxPyBeginAllowThreads();
39788 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39789 wxPyEndAllowThreads(__tstate);
39790 if (PyErr_Occurred()) SWIG_fail;
39791 }
39792 {
39793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39794 }
39795 return resultobj;
39796 fail:
39797 return NULL;
39798 }
39799
39800
39801 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39802 PyObject *resultobj = 0;
39803 wxMenu *arg1 = (wxMenu *) 0 ;
39804 int arg2 ;
39805 bool arg3 ;
39806 void *argp1 = 0 ;
39807 int res1 = 0 ;
39808 int val2 ;
39809 int ecode2 = 0 ;
39810 bool val3 ;
39811 int ecode3 = 0 ;
39812 PyObject * obj0 = 0 ;
39813 PyObject * obj1 = 0 ;
39814 PyObject * obj2 = 0 ;
39815 char * kwnames[] = {
39816 (char *) "self",(char *) "id",(char *) "check", NULL
39817 };
39818
39819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39821 if (!SWIG_IsOK(res1)) {
39822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39823 }
39824 arg1 = reinterpret_cast< wxMenu * >(argp1);
39825 ecode2 = SWIG_AsVal_int(obj1, &val2);
39826 if (!SWIG_IsOK(ecode2)) {
39827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39828 }
39829 arg2 = static_cast< int >(val2);
39830 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39831 if (!SWIG_IsOK(ecode3)) {
39832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39833 }
39834 arg3 = static_cast< bool >(val3);
39835 {
39836 PyThreadState* __tstate = wxPyBeginAllowThreads();
39837 (arg1)->Check(arg2,arg3);
39838 wxPyEndAllowThreads(__tstate);
39839 if (PyErr_Occurred()) SWIG_fail;
39840 }
39841 resultobj = SWIG_Py_Void();
39842 return resultobj;
39843 fail:
39844 return NULL;
39845 }
39846
39847
39848 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39849 PyObject *resultobj = 0;
39850 wxMenu *arg1 = (wxMenu *) 0 ;
39851 int arg2 ;
39852 bool result;
39853 void *argp1 = 0 ;
39854 int res1 = 0 ;
39855 int val2 ;
39856 int ecode2 = 0 ;
39857 PyObject * obj0 = 0 ;
39858 PyObject * obj1 = 0 ;
39859 char * kwnames[] = {
39860 (char *) "self",(char *) "id", NULL
39861 };
39862
39863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
39864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39865 if (!SWIG_IsOK(res1)) {
39866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
39867 }
39868 arg1 = reinterpret_cast< wxMenu * >(argp1);
39869 ecode2 = SWIG_AsVal_int(obj1, &val2);
39870 if (!SWIG_IsOK(ecode2)) {
39871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
39872 }
39873 arg2 = static_cast< int >(val2);
39874 {
39875 PyThreadState* __tstate = wxPyBeginAllowThreads();
39876 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
39877 wxPyEndAllowThreads(__tstate);
39878 if (PyErr_Occurred()) SWIG_fail;
39879 }
39880 {
39881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39882 }
39883 return resultobj;
39884 fail:
39885 return NULL;
39886 }
39887
39888
39889 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39890 PyObject *resultobj = 0;
39891 wxMenu *arg1 = (wxMenu *) 0 ;
39892 int arg2 ;
39893 wxString *arg3 = 0 ;
39894 void *argp1 = 0 ;
39895 int res1 = 0 ;
39896 int val2 ;
39897 int ecode2 = 0 ;
39898 bool temp3 = false ;
39899 PyObject * obj0 = 0 ;
39900 PyObject * obj1 = 0 ;
39901 PyObject * obj2 = 0 ;
39902 char * kwnames[] = {
39903 (char *) "self",(char *) "id",(char *) "label", NULL
39904 };
39905
39906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39908 if (!SWIG_IsOK(res1)) {
39909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
39910 }
39911 arg1 = reinterpret_cast< wxMenu * >(argp1);
39912 ecode2 = SWIG_AsVal_int(obj1, &val2);
39913 if (!SWIG_IsOK(ecode2)) {
39914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
39915 }
39916 arg2 = static_cast< int >(val2);
39917 {
39918 arg3 = wxString_in_helper(obj2);
39919 if (arg3 == NULL) SWIG_fail;
39920 temp3 = true;
39921 }
39922 {
39923 PyThreadState* __tstate = wxPyBeginAllowThreads();
39924 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
39925 wxPyEndAllowThreads(__tstate);
39926 if (PyErr_Occurred()) SWIG_fail;
39927 }
39928 resultobj = SWIG_Py_Void();
39929 {
39930 if (temp3)
39931 delete arg3;
39932 }
39933 return resultobj;
39934 fail:
39935 {
39936 if (temp3)
39937 delete arg3;
39938 }
39939 return NULL;
39940 }
39941
39942
39943 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39944 PyObject *resultobj = 0;
39945 wxMenu *arg1 = (wxMenu *) 0 ;
39946 int arg2 ;
39947 wxString result;
39948 void *argp1 = 0 ;
39949 int res1 = 0 ;
39950 int val2 ;
39951 int ecode2 = 0 ;
39952 PyObject * obj0 = 0 ;
39953 PyObject * obj1 = 0 ;
39954 char * kwnames[] = {
39955 (char *) "self",(char *) "id", NULL
39956 };
39957
39958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39960 if (!SWIG_IsOK(res1)) {
39961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
39962 }
39963 arg1 = reinterpret_cast< wxMenu * >(argp1);
39964 ecode2 = SWIG_AsVal_int(obj1, &val2);
39965 if (!SWIG_IsOK(ecode2)) {
39966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
39967 }
39968 arg2 = static_cast< int >(val2);
39969 {
39970 PyThreadState* __tstate = wxPyBeginAllowThreads();
39971 result = ((wxMenu const *)arg1)->GetLabel(arg2);
39972 wxPyEndAllowThreads(__tstate);
39973 if (PyErr_Occurred()) SWIG_fail;
39974 }
39975 {
39976 #if wxUSE_UNICODE
39977 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39978 #else
39979 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39980 #endif
39981 }
39982 return resultobj;
39983 fail:
39984 return NULL;
39985 }
39986
39987
39988 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39989 PyObject *resultobj = 0;
39990 wxMenu *arg1 = (wxMenu *) 0 ;
39991 int arg2 ;
39992 wxString *arg3 = 0 ;
39993 void *argp1 = 0 ;
39994 int res1 = 0 ;
39995 int val2 ;
39996 int ecode2 = 0 ;
39997 bool temp3 = false ;
39998 PyObject * obj0 = 0 ;
39999 PyObject * obj1 = 0 ;
40000 PyObject * obj2 = 0 ;
40001 char * kwnames[] = {
40002 (char *) "self",(char *) "id",(char *) "helpString", NULL
40003 };
40004
40005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40007 if (!SWIG_IsOK(res1)) {
40008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40009 }
40010 arg1 = reinterpret_cast< wxMenu * >(argp1);
40011 ecode2 = SWIG_AsVal_int(obj1, &val2);
40012 if (!SWIG_IsOK(ecode2)) {
40013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40014 }
40015 arg2 = static_cast< int >(val2);
40016 {
40017 arg3 = wxString_in_helper(obj2);
40018 if (arg3 == NULL) SWIG_fail;
40019 temp3 = true;
40020 }
40021 {
40022 PyThreadState* __tstate = wxPyBeginAllowThreads();
40023 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40024 wxPyEndAllowThreads(__tstate);
40025 if (PyErr_Occurred()) SWIG_fail;
40026 }
40027 resultobj = SWIG_Py_Void();
40028 {
40029 if (temp3)
40030 delete arg3;
40031 }
40032 return resultobj;
40033 fail:
40034 {
40035 if (temp3)
40036 delete arg3;
40037 }
40038 return NULL;
40039 }
40040
40041
40042 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40043 PyObject *resultobj = 0;
40044 wxMenu *arg1 = (wxMenu *) 0 ;
40045 int arg2 ;
40046 wxString result;
40047 void *argp1 = 0 ;
40048 int res1 = 0 ;
40049 int val2 ;
40050 int ecode2 = 0 ;
40051 PyObject * obj0 = 0 ;
40052 PyObject * obj1 = 0 ;
40053 char * kwnames[] = {
40054 (char *) "self",(char *) "id", NULL
40055 };
40056
40057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40059 if (!SWIG_IsOK(res1)) {
40060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40061 }
40062 arg1 = reinterpret_cast< wxMenu * >(argp1);
40063 ecode2 = SWIG_AsVal_int(obj1, &val2);
40064 if (!SWIG_IsOK(ecode2)) {
40065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40066 }
40067 arg2 = static_cast< int >(val2);
40068 {
40069 PyThreadState* __tstate = wxPyBeginAllowThreads();
40070 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40071 wxPyEndAllowThreads(__tstate);
40072 if (PyErr_Occurred()) SWIG_fail;
40073 }
40074 {
40075 #if wxUSE_UNICODE
40076 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40077 #else
40078 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40079 #endif
40080 }
40081 return resultobj;
40082 fail:
40083 return NULL;
40084 }
40085
40086
40087 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40088 PyObject *resultobj = 0;
40089 wxMenu *arg1 = (wxMenu *) 0 ;
40090 wxString *arg2 = 0 ;
40091 void *argp1 = 0 ;
40092 int res1 = 0 ;
40093 bool temp2 = false ;
40094 PyObject * obj0 = 0 ;
40095 PyObject * obj1 = 0 ;
40096 char * kwnames[] = {
40097 (char *) "self",(char *) "title", NULL
40098 };
40099
40100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40102 if (!SWIG_IsOK(res1)) {
40103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40104 }
40105 arg1 = reinterpret_cast< wxMenu * >(argp1);
40106 {
40107 arg2 = wxString_in_helper(obj1);
40108 if (arg2 == NULL) SWIG_fail;
40109 temp2 = true;
40110 }
40111 {
40112 PyThreadState* __tstate = wxPyBeginAllowThreads();
40113 (arg1)->SetTitle((wxString const &)*arg2);
40114 wxPyEndAllowThreads(__tstate);
40115 if (PyErr_Occurred()) SWIG_fail;
40116 }
40117 resultobj = SWIG_Py_Void();
40118 {
40119 if (temp2)
40120 delete arg2;
40121 }
40122 return resultobj;
40123 fail:
40124 {
40125 if (temp2)
40126 delete arg2;
40127 }
40128 return NULL;
40129 }
40130
40131
40132 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40133 PyObject *resultobj = 0;
40134 wxMenu *arg1 = (wxMenu *) 0 ;
40135 wxString result;
40136 void *argp1 = 0 ;
40137 int res1 = 0 ;
40138 PyObject *swig_obj[1] ;
40139
40140 if (!args) SWIG_fail;
40141 swig_obj[0] = args;
40142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40143 if (!SWIG_IsOK(res1)) {
40144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40145 }
40146 arg1 = reinterpret_cast< wxMenu * >(argp1);
40147 {
40148 PyThreadState* __tstate = wxPyBeginAllowThreads();
40149 result = ((wxMenu const *)arg1)->GetTitle();
40150 wxPyEndAllowThreads(__tstate);
40151 if (PyErr_Occurred()) SWIG_fail;
40152 }
40153 {
40154 #if wxUSE_UNICODE
40155 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40156 #else
40157 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40158 #endif
40159 }
40160 return resultobj;
40161 fail:
40162 return NULL;
40163 }
40164
40165
40166 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40167 PyObject *resultobj = 0;
40168 wxMenu *arg1 = (wxMenu *) 0 ;
40169 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40170 void *argp1 = 0 ;
40171 int res1 = 0 ;
40172 void *argp2 = 0 ;
40173 int res2 = 0 ;
40174 PyObject * obj0 = 0 ;
40175 PyObject * obj1 = 0 ;
40176 char * kwnames[] = {
40177 (char *) "self",(char *) "handler", NULL
40178 };
40179
40180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40182 if (!SWIG_IsOK(res1)) {
40183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40184 }
40185 arg1 = reinterpret_cast< wxMenu * >(argp1);
40186 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40187 if (!SWIG_IsOK(res2)) {
40188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40189 }
40190 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40191 {
40192 PyThreadState* __tstate = wxPyBeginAllowThreads();
40193 (arg1)->SetEventHandler(arg2);
40194 wxPyEndAllowThreads(__tstate);
40195 if (PyErr_Occurred()) SWIG_fail;
40196 }
40197 resultobj = SWIG_Py_Void();
40198 return resultobj;
40199 fail:
40200 return NULL;
40201 }
40202
40203
40204 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40205 PyObject *resultobj = 0;
40206 wxMenu *arg1 = (wxMenu *) 0 ;
40207 wxEvtHandler *result = 0 ;
40208 void *argp1 = 0 ;
40209 int res1 = 0 ;
40210 PyObject *swig_obj[1] ;
40211
40212 if (!args) SWIG_fail;
40213 swig_obj[0] = args;
40214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40215 if (!SWIG_IsOK(res1)) {
40216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40217 }
40218 arg1 = reinterpret_cast< wxMenu * >(argp1);
40219 {
40220 PyThreadState* __tstate = wxPyBeginAllowThreads();
40221 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40222 wxPyEndAllowThreads(__tstate);
40223 if (PyErr_Occurred()) SWIG_fail;
40224 }
40225 {
40226 resultobj = wxPyMake_wxObject(result, 0);
40227 }
40228 return resultobj;
40229 fail:
40230 return NULL;
40231 }
40232
40233
40234 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40235 PyObject *resultobj = 0;
40236 wxMenu *arg1 = (wxMenu *) 0 ;
40237 wxWindow *arg2 = (wxWindow *) 0 ;
40238 void *argp1 = 0 ;
40239 int res1 = 0 ;
40240 void *argp2 = 0 ;
40241 int res2 = 0 ;
40242 PyObject * obj0 = 0 ;
40243 PyObject * obj1 = 0 ;
40244 char * kwnames[] = {
40245 (char *) "self",(char *) "win", NULL
40246 };
40247
40248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40250 if (!SWIG_IsOK(res1)) {
40251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40252 }
40253 arg1 = reinterpret_cast< wxMenu * >(argp1);
40254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40255 if (!SWIG_IsOK(res2)) {
40256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40257 }
40258 arg2 = reinterpret_cast< wxWindow * >(argp2);
40259 {
40260 PyThreadState* __tstate = wxPyBeginAllowThreads();
40261 (arg1)->SetInvokingWindow(arg2);
40262 wxPyEndAllowThreads(__tstate);
40263 if (PyErr_Occurred()) SWIG_fail;
40264 }
40265 resultobj = SWIG_Py_Void();
40266 return resultobj;
40267 fail:
40268 return NULL;
40269 }
40270
40271
40272 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40273 PyObject *resultobj = 0;
40274 wxMenu *arg1 = (wxMenu *) 0 ;
40275 wxWindow *result = 0 ;
40276 void *argp1 = 0 ;
40277 int res1 = 0 ;
40278 PyObject *swig_obj[1] ;
40279
40280 if (!args) SWIG_fail;
40281 swig_obj[0] = args;
40282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40283 if (!SWIG_IsOK(res1)) {
40284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40285 }
40286 arg1 = reinterpret_cast< wxMenu * >(argp1);
40287 {
40288 PyThreadState* __tstate = wxPyBeginAllowThreads();
40289 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40290 wxPyEndAllowThreads(__tstate);
40291 if (PyErr_Occurred()) SWIG_fail;
40292 }
40293 {
40294 resultobj = wxPyMake_wxObject(result, 0);
40295 }
40296 return resultobj;
40297 fail:
40298 return NULL;
40299 }
40300
40301
40302 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40303 PyObject *resultobj = 0;
40304 wxMenu *arg1 = (wxMenu *) 0 ;
40305 long result;
40306 void *argp1 = 0 ;
40307 int res1 = 0 ;
40308 PyObject *swig_obj[1] ;
40309
40310 if (!args) SWIG_fail;
40311 swig_obj[0] = args;
40312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40313 if (!SWIG_IsOK(res1)) {
40314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40315 }
40316 arg1 = reinterpret_cast< wxMenu * >(argp1);
40317 {
40318 PyThreadState* __tstate = wxPyBeginAllowThreads();
40319 result = (long)((wxMenu const *)arg1)->GetStyle();
40320 wxPyEndAllowThreads(__tstate);
40321 if (PyErr_Occurred()) SWIG_fail;
40322 }
40323 resultobj = SWIG_From_long(static_cast< long >(result));
40324 return resultobj;
40325 fail:
40326 return NULL;
40327 }
40328
40329
40330 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40331 PyObject *resultobj = 0;
40332 wxMenu *arg1 = (wxMenu *) 0 ;
40333 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40334 void *argp1 = 0 ;
40335 int res1 = 0 ;
40336 void *argp2 = 0 ;
40337 int res2 = 0 ;
40338 PyObject * obj0 = 0 ;
40339 PyObject * obj1 = 0 ;
40340 char * kwnames[] = {
40341 (char *) "self",(char *) "source", NULL
40342 };
40343
40344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40346 if (!SWIG_IsOK(res1)) {
40347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40348 }
40349 arg1 = reinterpret_cast< wxMenu * >(argp1);
40350 if (obj1) {
40351 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40352 if (!SWIG_IsOK(res2)) {
40353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40354 }
40355 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40356 }
40357 {
40358 PyThreadState* __tstate = wxPyBeginAllowThreads();
40359 (arg1)->UpdateUI(arg2);
40360 wxPyEndAllowThreads(__tstate);
40361 if (PyErr_Occurred()) SWIG_fail;
40362 }
40363 resultobj = SWIG_Py_Void();
40364 return resultobj;
40365 fail:
40366 return NULL;
40367 }
40368
40369
40370 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40371 PyObject *resultobj = 0;
40372 wxMenu *arg1 = (wxMenu *) 0 ;
40373 wxMenuBar *result = 0 ;
40374 void *argp1 = 0 ;
40375 int res1 = 0 ;
40376 PyObject *swig_obj[1] ;
40377
40378 if (!args) SWIG_fail;
40379 swig_obj[0] = args;
40380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40381 if (!SWIG_IsOK(res1)) {
40382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40383 }
40384 arg1 = reinterpret_cast< wxMenu * >(argp1);
40385 {
40386 PyThreadState* __tstate = wxPyBeginAllowThreads();
40387 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40388 wxPyEndAllowThreads(__tstate);
40389 if (PyErr_Occurred()) SWIG_fail;
40390 }
40391 {
40392 resultobj = wxPyMake_wxObject(result, (bool)0);
40393 }
40394 return resultobj;
40395 fail:
40396 return NULL;
40397 }
40398
40399
40400 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40401 PyObject *resultobj = 0;
40402 wxMenu *arg1 = (wxMenu *) 0 ;
40403 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40404 void *argp1 = 0 ;
40405 int res1 = 0 ;
40406 void *argp2 = 0 ;
40407 int res2 = 0 ;
40408 PyObject * obj0 = 0 ;
40409 PyObject * obj1 = 0 ;
40410 char * kwnames[] = {
40411 (char *) "self",(char *) "menubar", NULL
40412 };
40413
40414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40416 if (!SWIG_IsOK(res1)) {
40417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40418 }
40419 arg1 = reinterpret_cast< wxMenu * >(argp1);
40420 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40421 if (!SWIG_IsOK(res2)) {
40422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40423 }
40424 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40425 {
40426 PyThreadState* __tstate = wxPyBeginAllowThreads();
40427 (arg1)->Attach(arg2);
40428 wxPyEndAllowThreads(__tstate);
40429 if (PyErr_Occurred()) SWIG_fail;
40430 }
40431 resultobj = SWIG_Py_Void();
40432 return resultobj;
40433 fail:
40434 return NULL;
40435 }
40436
40437
40438 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40439 PyObject *resultobj = 0;
40440 wxMenu *arg1 = (wxMenu *) 0 ;
40441 void *argp1 = 0 ;
40442 int res1 = 0 ;
40443 PyObject *swig_obj[1] ;
40444
40445 if (!args) SWIG_fail;
40446 swig_obj[0] = args;
40447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40448 if (!SWIG_IsOK(res1)) {
40449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40450 }
40451 arg1 = reinterpret_cast< wxMenu * >(argp1);
40452 {
40453 PyThreadState* __tstate = wxPyBeginAllowThreads();
40454 (arg1)->Detach();
40455 wxPyEndAllowThreads(__tstate);
40456 if (PyErr_Occurred()) SWIG_fail;
40457 }
40458 resultobj = SWIG_Py_Void();
40459 return resultobj;
40460 fail:
40461 return NULL;
40462 }
40463
40464
40465 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40466 PyObject *resultobj = 0;
40467 wxMenu *arg1 = (wxMenu *) 0 ;
40468 bool result;
40469 void *argp1 = 0 ;
40470 int res1 = 0 ;
40471 PyObject *swig_obj[1] ;
40472
40473 if (!args) SWIG_fail;
40474 swig_obj[0] = args;
40475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40476 if (!SWIG_IsOK(res1)) {
40477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40478 }
40479 arg1 = reinterpret_cast< wxMenu * >(argp1);
40480 {
40481 PyThreadState* __tstate = wxPyBeginAllowThreads();
40482 result = (bool)((wxMenu const *)arg1)->IsAttached();
40483 wxPyEndAllowThreads(__tstate);
40484 if (PyErr_Occurred()) SWIG_fail;
40485 }
40486 {
40487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40488 }
40489 return resultobj;
40490 fail:
40491 return NULL;
40492 }
40493
40494
40495 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40496 PyObject *resultobj = 0;
40497 wxMenu *arg1 = (wxMenu *) 0 ;
40498 wxMenu *arg2 = (wxMenu *) 0 ;
40499 void *argp1 = 0 ;
40500 int res1 = 0 ;
40501 void *argp2 = 0 ;
40502 int res2 = 0 ;
40503 PyObject * obj0 = 0 ;
40504 PyObject * obj1 = 0 ;
40505 char * kwnames[] = {
40506 (char *) "self",(char *) "parent", NULL
40507 };
40508
40509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40511 if (!SWIG_IsOK(res1)) {
40512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40513 }
40514 arg1 = reinterpret_cast< wxMenu * >(argp1);
40515 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40516 if (!SWIG_IsOK(res2)) {
40517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40518 }
40519 arg2 = reinterpret_cast< wxMenu * >(argp2);
40520 {
40521 PyThreadState* __tstate = wxPyBeginAllowThreads();
40522 (arg1)->SetParent(arg2);
40523 wxPyEndAllowThreads(__tstate);
40524 if (PyErr_Occurred()) SWIG_fail;
40525 }
40526 resultobj = SWIG_Py_Void();
40527 return resultobj;
40528 fail:
40529 return NULL;
40530 }
40531
40532
40533 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40534 PyObject *resultobj = 0;
40535 wxMenu *arg1 = (wxMenu *) 0 ;
40536 wxMenu *result = 0 ;
40537 void *argp1 = 0 ;
40538 int res1 = 0 ;
40539 PyObject *swig_obj[1] ;
40540
40541 if (!args) SWIG_fail;
40542 swig_obj[0] = args;
40543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40544 if (!SWIG_IsOK(res1)) {
40545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40546 }
40547 arg1 = reinterpret_cast< wxMenu * >(argp1);
40548 {
40549 PyThreadState* __tstate = wxPyBeginAllowThreads();
40550 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40551 wxPyEndAllowThreads(__tstate);
40552 if (PyErr_Occurred()) SWIG_fail;
40553 }
40554 {
40555 resultobj = wxPyMake_wxObject(result, 0);
40556 }
40557 return resultobj;
40558 fail:
40559 return NULL;
40560 }
40561
40562
40563 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40564 PyObject *obj;
40565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40566 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40567 return SWIG_Py_Void();
40568 }
40569
40570 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40571 return SWIG_Python_InitShadowInstance(args);
40572 }
40573
40574 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40575 PyObject *resultobj = 0;
40576 long arg1 = (long) 0 ;
40577 wxMenuBar *result = 0 ;
40578 long val1 ;
40579 int ecode1 = 0 ;
40580 PyObject * obj0 = 0 ;
40581 char * kwnames[] = {
40582 (char *) "style", NULL
40583 };
40584
40585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40586 if (obj0) {
40587 ecode1 = SWIG_AsVal_long(obj0, &val1);
40588 if (!SWIG_IsOK(ecode1)) {
40589 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40590 }
40591 arg1 = static_cast< long >(val1);
40592 }
40593 {
40594 if (!wxPyCheckForApp()) SWIG_fail;
40595 PyThreadState* __tstate = wxPyBeginAllowThreads();
40596 result = (wxMenuBar *)new wxMenuBar(arg1);
40597 wxPyEndAllowThreads(__tstate);
40598 if (PyErr_Occurred()) SWIG_fail;
40599 }
40600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40601 return resultobj;
40602 fail:
40603 return NULL;
40604 }
40605
40606
40607 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40608 PyObject *resultobj = 0;
40609 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40610 wxMenu *arg2 = (wxMenu *) 0 ;
40611 wxString *arg3 = 0 ;
40612 bool result;
40613 void *argp1 = 0 ;
40614 int res1 = 0 ;
40615 void *argp2 = 0 ;
40616 int res2 = 0 ;
40617 bool temp3 = false ;
40618 PyObject * obj0 = 0 ;
40619 PyObject * obj1 = 0 ;
40620 PyObject * obj2 = 0 ;
40621 char * kwnames[] = {
40622 (char *) "self",(char *) "menu",(char *) "title", NULL
40623 };
40624
40625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40627 if (!SWIG_IsOK(res1)) {
40628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40629 }
40630 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40631 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40632 if (!SWIG_IsOK(res2)) {
40633 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40634 }
40635 arg2 = reinterpret_cast< wxMenu * >(argp2);
40636 {
40637 arg3 = wxString_in_helper(obj2);
40638 if (arg3 == NULL) SWIG_fail;
40639 temp3 = true;
40640 }
40641 {
40642 PyThreadState* __tstate = wxPyBeginAllowThreads();
40643 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40644 wxPyEndAllowThreads(__tstate);
40645 if (PyErr_Occurred()) SWIG_fail;
40646 }
40647 {
40648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40649 }
40650 {
40651 if (temp3)
40652 delete arg3;
40653 }
40654 return resultobj;
40655 fail:
40656 {
40657 if (temp3)
40658 delete arg3;
40659 }
40660 return NULL;
40661 }
40662
40663
40664 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40665 PyObject *resultobj = 0;
40666 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40667 size_t arg2 ;
40668 wxMenu *arg3 = (wxMenu *) 0 ;
40669 wxString *arg4 = 0 ;
40670 bool result;
40671 void *argp1 = 0 ;
40672 int res1 = 0 ;
40673 size_t val2 ;
40674 int ecode2 = 0 ;
40675 void *argp3 = 0 ;
40676 int res3 = 0 ;
40677 bool temp4 = false ;
40678 PyObject * obj0 = 0 ;
40679 PyObject * obj1 = 0 ;
40680 PyObject * obj2 = 0 ;
40681 PyObject * obj3 = 0 ;
40682 char * kwnames[] = {
40683 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40684 };
40685
40686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40688 if (!SWIG_IsOK(res1)) {
40689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40690 }
40691 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40692 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40693 if (!SWIG_IsOK(ecode2)) {
40694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40695 }
40696 arg2 = static_cast< size_t >(val2);
40697 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40698 if (!SWIG_IsOK(res3)) {
40699 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40700 }
40701 arg3 = reinterpret_cast< wxMenu * >(argp3);
40702 {
40703 arg4 = wxString_in_helper(obj3);
40704 if (arg4 == NULL) SWIG_fail;
40705 temp4 = true;
40706 }
40707 {
40708 PyThreadState* __tstate = wxPyBeginAllowThreads();
40709 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40710 wxPyEndAllowThreads(__tstate);
40711 if (PyErr_Occurred()) SWIG_fail;
40712 }
40713 {
40714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40715 }
40716 {
40717 if (temp4)
40718 delete arg4;
40719 }
40720 return resultobj;
40721 fail:
40722 {
40723 if (temp4)
40724 delete arg4;
40725 }
40726 return NULL;
40727 }
40728
40729
40730 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40731 PyObject *resultobj = 0;
40732 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40733 size_t result;
40734 void *argp1 = 0 ;
40735 int res1 = 0 ;
40736 PyObject *swig_obj[1] ;
40737
40738 if (!args) SWIG_fail;
40739 swig_obj[0] = args;
40740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40741 if (!SWIG_IsOK(res1)) {
40742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40743 }
40744 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40745 {
40746 PyThreadState* __tstate = wxPyBeginAllowThreads();
40747 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40748 wxPyEndAllowThreads(__tstate);
40749 if (PyErr_Occurred()) SWIG_fail;
40750 }
40751 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40752 return resultobj;
40753 fail:
40754 return NULL;
40755 }
40756
40757
40758 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40759 PyObject *resultobj = 0;
40760 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40761 size_t arg2 ;
40762 wxMenu *result = 0 ;
40763 void *argp1 = 0 ;
40764 int res1 = 0 ;
40765 size_t val2 ;
40766 int ecode2 = 0 ;
40767 PyObject * obj0 = 0 ;
40768 PyObject * obj1 = 0 ;
40769 char * kwnames[] = {
40770 (char *) "self",(char *) "pos", NULL
40771 };
40772
40773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40775 if (!SWIG_IsOK(res1)) {
40776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40777 }
40778 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40779 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40780 if (!SWIG_IsOK(ecode2)) {
40781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40782 }
40783 arg2 = static_cast< size_t >(val2);
40784 {
40785 PyThreadState* __tstate = wxPyBeginAllowThreads();
40786 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40787 wxPyEndAllowThreads(__tstate);
40788 if (PyErr_Occurred()) SWIG_fail;
40789 }
40790 {
40791 resultobj = wxPyMake_wxObject(result, 0);
40792 }
40793 return resultobj;
40794 fail:
40795 return NULL;
40796 }
40797
40798
40799 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40800 PyObject *resultobj = 0;
40801 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40802 size_t arg2 ;
40803 wxMenu *arg3 = (wxMenu *) 0 ;
40804 wxString *arg4 = 0 ;
40805 wxMenu *result = 0 ;
40806 void *argp1 = 0 ;
40807 int res1 = 0 ;
40808 size_t val2 ;
40809 int ecode2 = 0 ;
40810 void *argp3 = 0 ;
40811 int res3 = 0 ;
40812 bool temp4 = false ;
40813 PyObject * obj0 = 0 ;
40814 PyObject * obj1 = 0 ;
40815 PyObject * obj2 = 0 ;
40816 PyObject * obj3 = 0 ;
40817 char * kwnames[] = {
40818 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40819 };
40820
40821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40823 if (!SWIG_IsOK(res1)) {
40824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40825 }
40826 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40827 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40828 if (!SWIG_IsOK(ecode2)) {
40829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40830 }
40831 arg2 = static_cast< size_t >(val2);
40832 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40833 if (!SWIG_IsOK(res3)) {
40834 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40835 }
40836 arg3 = reinterpret_cast< wxMenu * >(argp3);
40837 {
40838 arg4 = wxString_in_helper(obj3);
40839 if (arg4 == NULL) SWIG_fail;
40840 temp4 = true;
40841 }
40842 {
40843 PyThreadState* __tstate = wxPyBeginAllowThreads();
40844 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40845 wxPyEndAllowThreads(__tstate);
40846 if (PyErr_Occurred()) SWIG_fail;
40847 }
40848 {
40849 resultobj = wxPyMake_wxObject(result, 0);
40850 }
40851 {
40852 if (temp4)
40853 delete arg4;
40854 }
40855 return resultobj;
40856 fail:
40857 {
40858 if (temp4)
40859 delete arg4;
40860 }
40861 return NULL;
40862 }
40863
40864
40865 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40866 PyObject *resultobj = 0;
40867 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40868 size_t arg2 ;
40869 wxMenu *result = 0 ;
40870 void *argp1 = 0 ;
40871 int res1 = 0 ;
40872 size_t val2 ;
40873 int ecode2 = 0 ;
40874 PyObject * obj0 = 0 ;
40875 PyObject * obj1 = 0 ;
40876 char * kwnames[] = {
40877 (char *) "self",(char *) "pos", NULL
40878 };
40879
40880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40882 if (!SWIG_IsOK(res1)) {
40883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40884 }
40885 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40886 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40887 if (!SWIG_IsOK(ecode2)) {
40888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
40889 }
40890 arg2 = static_cast< size_t >(val2);
40891 {
40892 PyThreadState* __tstate = wxPyBeginAllowThreads();
40893 result = (wxMenu *)(arg1)->Remove(arg2);
40894 wxPyEndAllowThreads(__tstate);
40895 if (PyErr_Occurred()) SWIG_fail;
40896 }
40897 {
40898 resultobj = wxPyMake_wxObject(result, 0);
40899 }
40900 return resultobj;
40901 fail:
40902 return NULL;
40903 }
40904
40905
40906 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40907 PyObject *resultobj = 0;
40908 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40909 size_t arg2 ;
40910 bool arg3 ;
40911 void *argp1 = 0 ;
40912 int res1 = 0 ;
40913 size_t val2 ;
40914 int ecode2 = 0 ;
40915 bool val3 ;
40916 int ecode3 = 0 ;
40917 PyObject * obj0 = 0 ;
40918 PyObject * obj1 = 0 ;
40919 PyObject * obj2 = 0 ;
40920 char * kwnames[] = {
40921 (char *) "self",(char *) "pos",(char *) "enable", NULL
40922 };
40923
40924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40926 if (!SWIG_IsOK(res1)) {
40927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40928 }
40929 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40930 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40931 if (!SWIG_IsOK(ecode2)) {
40932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
40933 }
40934 arg2 = static_cast< size_t >(val2);
40935 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40936 if (!SWIG_IsOK(ecode3)) {
40937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
40938 }
40939 arg3 = static_cast< bool >(val3);
40940 {
40941 PyThreadState* __tstate = wxPyBeginAllowThreads();
40942 (arg1)->EnableTop(arg2,arg3);
40943 wxPyEndAllowThreads(__tstate);
40944 if (PyErr_Occurred()) SWIG_fail;
40945 }
40946 resultobj = SWIG_Py_Void();
40947 return resultobj;
40948 fail:
40949 return NULL;
40950 }
40951
40952
40953 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40954 PyObject *resultobj = 0;
40955 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40956 size_t arg2 ;
40957 bool result;
40958 void *argp1 = 0 ;
40959 int res1 = 0 ;
40960 size_t val2 ;
40961 int ecode2 = 0 ;
40962 PyObject * obj0 = 0 ;
40963 PyObject * obj1 = 0 ;
40964 char * kwnames[] = {
40965 (char *) "self",(char *) "pos", NULL
40966 };
40967
40968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
40969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40970 if (!SWIG_IsOK(res1)) {
40971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40972 }
40973 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40974 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40975 if (!SWIG_IsOK(ecode2)) {
40976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
40977 }
40978 arg2 = static_cast< size_t >(val2);
40979 {
40980 PyThreadState* __tstate = wxPyBeginAllowThreads();
40981 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
40982 wxPyEndAllowThreads(__tstate);
40983 if (PyErr_Occurred()) SWIG_fail;
40984 }
40985 {
40986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40987 }
40988 return resultobj;
40989 fail:
40990 return NULL;
40991 }
40992
40993
40994 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40995 PyObject *resultobj = 0;
40996 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40997 size_t arg2 ;
40998 wxString *arg3 = 0 ;
40999 void *argp1 = 0 ;
41000 int res1 = 0 ;
41001 size_t val2 ;
41002 int ecode2 = 0 ;
41003 bool temp3 = false ;
41004 PyObject * obj0 = 0 ;
41005 PyObject * obj1 = 0 ;
41006 PyObject * obj2 = 0 ;
41007 char * kwnames[] = {
41008 (char *) "self",(char *) "pos",(char *) "label", NULL
41009 };
41010
41011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41013 if (!SWIG_IsOK(res1)) {
41014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41015 }
41016 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41017 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41018 if (!SWIG_IsOK(ecode2)) {
41019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41020 }
41021 arg2 = static_cast< size_t >(val2);
41022 {
41023 arg3 = wxString_in_helper(obj2);
41024 if (arg3 == NULL) SWIG_fail;
41025 temp3 = true;
41026 }
41027 {
41028 PyThreadState* __tstate = wxPyBeginAllowThreads();
41029 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41030 wxPyEndAllowThreads(__tstate);
41031 if (PyErr_Occurred()) SWIG_fail;
41032 }
41033 resultobj = SWIG_Py_Void();
41034 {
41035 if (temp3)
41036 delete arg3;
41037 }
41038 return resultobj;
41039 fail:
41040 {
41041 if (temp3)
41042 delete arg3;
41043 }
41044 return NULL;
41045 }
41046
41047
41048 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41049 PyObject *resultobj = 0;
41050 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41051 size_t arg2 ;
41052 wxString result;
41053 void *argp1 = 0 ;
41054 int res1 = 0 ;
41055 size_t val2 ;
41056 int ecode2 = 0 ;
41057 PyObject * obj0 = 0 ;
41058 PyObject * obj1 = 0 ;
41059 char * kwnames[] = {
41060 (char *) "self",(char *) "pos", NULL
41061 };
41062
41063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41065 if (!SWIG_IsOK(res1)) {
41066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41067 }
41068 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41069 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41070 if (!SWIG_IsOK(ecode2)) {
41071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41072 }
41073 arg2 = static_cast< size_t >(val2);
41074 {
41075 PyThreadState* __tstate = wxPyBeginAllowThreads();
41076 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41077 wxPyEndAllowThreads(__tstate);
41078 if (PyErr_Occurred()) SWIG_fail;
41079 }
41080 {
41081 #if wxUSE_UNICODE
41082 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41083 #else
41084 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41085 #endif
41086 }
41087 return resultobj;
41088 fail:
41089 return NULL;
41090 }
41091
41092
41093 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41094 PyObject *resultobj = 0;
41095 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41096 wxString *arg2 = 0 ;
41097 wxString *arg3 = 0 ;
41098 int result;
41099 void *argp1 = 0 ;
41100 int res1 = 0 ;
41101 bool temp2 = false ;
41102 bool temp3 = false ;
41103 PyObject * obj0 = 0 ;
41104 PyObject * obj1 = 0 ;
41105 PyObject * obj2 = 0 ;
41106 char * kwnames[] = {
41107 (char *) "self",(char *) "menu",(char *) "item", NULL
41108 };
41109
41110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41112 if (!SWIG_IsOK(res1)) {
41113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41114 }
41115 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41116 {
41117 arg2 = wxString_in_helper(obj1);
41118 if (arg2 == NULL) SWIG_fail;
41119 temp2 = true;
41120 }
41121 {
41122 arg3 = wxString_in_helper(obj2);
41123 if (arg3 == NULL) SWIG_fail;
41124 temp3 = true;
41125 }
41126 {
41127 PyThreadState* __tstate = wxPyBeginAllowThreads();
41128 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41129 wxPyEndAllowThreads(__tstate);
41130 if (PyErr_Occurred()) SWIG_fail;
41131 }
41132 resultobj = SWIG_From_int(static_cast< int >(result));
41133 {
41134 if (temp2)
41135 delete arg2;
41136 }
41137 {
41138 if (temp3)
41139 delete arg3;
41140 }
41141 return resultobj;
41142 fail:
41143 {
41144 if (temp2)
41145 delete arg2;
41146 }
41147 {
41148 if (temp3)
41149 delete arg3;
41150 }
41151 return NULL;
41152 }
41153
41154
41155 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41156 PyObject *resultobj = 0;
41157 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41158 int arg2 ;
41159 wxMenuItem *result = 0 ;
41160 void *argp1 = 0 ;
41161 int res1 = 0 ;
41162 int val2 ;
41163 int ecode2 = 0 ;
41164 PyObject * obj0 = 0 ;
41165 PyObject * obj1 = 0 ;
41166 char * kwnames[] = {
41167 (char *) "self",(char *) "id", NULL
41168 };
41169
41170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41172 if (!SWIG_IsOK(res1)) {
41173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41174 }
41175 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41176 ecode2 = SWIG_AsVal_int(obj1, &val2);
41177 if (!SWIG_IsOK(ecode2)) {
41178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41179 }
41180 arg2 = static_cast< int >(val2);
41181 {
41182 PyThreadState* __tstate = wxPyBeginAllowThreads();
41183 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41184 wxPyEndAllowThreads(__tstate);
41185 if (PyErr_Occurred()) SWIG_fail;
41186 }
41187 {
41188 resultobj = wxPyMake_wxObject(result, (bool)0);
41189 }
41190 return resultobj;
41191 fail:
41192 return NULL;
41193 }
41194
41195
41196 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41197 PyObject *resultobj = 0;
41198 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41199 wxString *arg2 = 0 ;
41200 int result;
41201 void *argp1 = 0 ;
41202 int res1 = 0 ;
41203 bool temp2 = false ;
41204 PyObject * obj0 = 0 ;
41205 PyObject * obj1 = 0 ;
41206 char * kwnames[] = {
41207 (char *) "self",(char *) "title", NULL
41208 };
41209
41210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41212 if (!SWIG_IsOK(res1)) {
41213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41214 }
41215 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41216 {
41217 arg2 = wxString_in_helper(obj1);
41218 if (arg2 == NULL) SWIG_fail;
41219 temp2 = true;
41220 }
41221 {
41222 PyThreadState* __tstate = wxPyBeginAllowThreads();
41223 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41224 wxPyEndAllowThreads(__tstate);
41225 if (PyErr_Occurred()) SWIG_fail;
41226 }
41227 resultobj = SWIG_From_int(static_cast< int >(result));
41228 {
41229 if (temp2)
41230 delete arg2;
41231 }
41232 return resultobj;
41233 fail:
41234 {
41235 if (temp2)
41236 delete arg2;
41237 }
41238 return NULL;
41239 }
41240
41241
41242 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41243 PyObject *resultobj = 0;
41244 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41245 int arg2 ;
41246 bool arg3 ;
41247 void *argp1 = 0 ;
41248 int res1 = 0 ;
41249 int val2 ;
41250 int ecode2 = 0 ;
41251 bool val3 ;
41252 int ecode3 = 0 ;
41253 PyObject * obj0 = 0 ;
41254 PyObject * obj1 = 0 ;
41255 PyObject * obj2 = 0 ;
41256 char * kwnames[] = {
41257 (char *) "self",(char *) "id",(char *) "enable", NULL
41258 };
41259
41260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41262 if (!SWIG_IsOK(res1)) {
41263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41264 }
41265 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41266 ecode2 = SWIG_AsVal_int(obj1, &val2);
41267 if (!SWIG_IsOK(ecode2)) {
41268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41269 }
41270 arg2 = static_cast< int >(val2);
41271 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41272 if (!SWIG_IsOK(ecode3)) {
41273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41274 }
41275 arg3 = static_cast< bool >(val3);
41276 {
41277 PyThreadState* __tstate = wxPyBeginAllowThreads();
41278 (arg1)->Enable(arg2,arg3);
41279 wxPyEndAllowThreads(__tstate);
41280 if (PyErr_Occurred()) SWIG_fail;
41281 }
41282 resultobj = SWIG_Py_Void();
41283 return resultobj;
41284 fail:
41285 return NULL;
41286 }
41287
41288
41289 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41290 PyObject *resultobj = 0;
41291 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41292 int arg2 ;
41293 bool arg3 ;
41294 void *argp1 = 0 ;
41295 int res1 = 0 ;
41296 int val2 ;
41297 int ecode2 = 0 ;
41298 bool val3 ;
41299 int ecode3 = 0 ;
41300 PyObject * obj0 = 0 ;
41301 PyObject * obj1 = 0 ;
41302 PyObject * obj2 = 0 ;
41303 char * kwnames[] = {
41304 (char *) "self",(char *) "id",(char *) "check", NULL
41305 };
41306
41307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41309 if (!SWIG_IsOK(res1)) {
41310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41311 }
41312 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41313 ecode2 = SWIG_AsVal_int(obj1, &val2);
41314 if (!SWIG_IsOK(ecode2)) {
41315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41316 }
41317 arg2 = static_cast< int >(val2);
41318 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41319 if (!SWIG_IsOK(ecode3)) {
41320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41321 }
41322 arg3 = static_cast< bool >(val3);
41323 {
41324 PyThreadState* __tstate = wxPyBeginAllowThreads();
41325 (arg1)->Check(arg2,arg3);
41326 wxPyEndAllowThreads(__tstate);
41327 if (PyErr_Occurred()) SWIG_fail;
41328 }
41329 resultobj = SWIG_Py_Void();
41330 return resultobj;
41331 fail:
41332 return NULL;
41333 }
41334
41335
41336 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41337 PyObject *resultobj = 0;
41338 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41339 int arg2 ;
41340 bool result;
41341 void *argp1 = 0 ;
41342 int res1 = 0 ;
41343 int val2 ;
41344 int ecode2 = 0 ;
41345 PyObject * obj0 = 0 ;
41346 PyObject * obj1 = 0 ;
41347 char * kwnames[] = {
41348 (char *) "self",(char *) "id", NULL
41349 };
41350
41351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41353 if (!SWIG_IsOK(res1)) {
41354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41355 }
41356 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41357 ecode2 = SWIG_AsVal_int(obj1, &val2);
41358 if (!SWIG_IsOK(ecode2)) {
41359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41360 }
41361 arg2 = static_cast< int >(val2);
41362 {
41363 PyThreadState* __tstate = wxPyBeginAllowThreads();
41364 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41365 wxPyEndAllowThreads(__tstate);
41366 if (PyErr_Occurred()) SWIG_fail;
41367 }
41368 {
41369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41370 }
41371 return resultobj;
41372 fail:
41373 return NULL;
41374 }
41375
41376
41377 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41378 PyObject *resultobj = 0;
41379 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41380 int arg2 ;
41381 bool result;
41382 void *argp1 = 0 ;
41383 int res1 = 0 ;
41384 int val2 ;
41385 int ecode2 = 0 ;
41386 PyObject * obj0 = 0 ;
41387 PyObject * obj1 = 0 ;
41388 char * kwnames[] = {
41389 (char *) "self",(char *) "id", NULL
41390 };
41391
41392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41394 if (!SWIG_IsOK(res1)) {
41395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41396 }
41397 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41398 ecode2 = SWIG_AsVal_int(obj1, &val2);
41399 if (!SWIG_IsOK(ecode2)) {
41400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41401 }
41402 arg2 = static_cast< int >(val2);
41403 {
41404 PyThreadState* __tstate = wxPyBeginAllowThreads();
41405 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41406 wxPyEndAllowThreads(__tstate);
41407 if (PyErr_Occurred()) SWIG_fail;
41408 }
41409 {
41410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41411 }
41412 return resultobj;
41413 fail:
41414 return NULL;
41415 }
41416
41417
41418 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41419 PyObject *resultobj = 0;
41420 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41421 int arg2 ;
41422 wxString *arg3 = 0 ;
41423 void *argp1 = 0 ;
41424 int res1 = 0 ;
41425 int val2 ;
41426 int ecode2 = 0 ;
41427 bool temp3 = false ;
41428 PyObject * obj0 = 0 ;
41429 PyObject * obj1 = 0 ;
41430 PyObject * obj2 = 0 ;
41431 char * kwnames[] = {
41432 (char *) "self",(char *) "id",(char *) "label", NULL
41433 };
41434
41435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41437 if (!SWIG_IsOK(res1)) {
41438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41439 }
41440 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41441 ecode2 = SWIG_AsVal_int(obj1, &val2);
41442 if (!SWIG_IsOK(ecode2)) {
41443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41444 }
41445 arg2 = static_cast< int >(val2);
41446 {
41447 arg3 = wxString_in_helper(obj2);
41448 if (arg3 == NULL) SWIG_fail;
41449 temp3 = true;
41450 }
41451 {
41452 PyThreadState* __tstate = wxPyBeginAllowThreads();
41453 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41454 wxPyEndAllowThreads(__tstate);
41455 if (PyErr_Occurred()) SWIG_fail;
41456 }
41457 resultobj = SWIG_Py_Void();
41458 {
41459 if (temp3)
41460 delete arg3;
41461 }
41462 return resultobj;
41463 fail:
41464 {
41465 if (temp3)
41466 delete arg3;
41467 }
41468 return NULL;
41469 }
41470
41471
41472 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41473 PyObject *resultobj = 0;
41474 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41475 int arg2 ;
41476 wxString result;
41477 void *argp1 = 0 ;
41478 int res1 = 0 ;
41479 int val2 ;
41480 int ecode2 = 0 ;
41481 PyObject * obj0 = 0 ;
41482 PyObject * obj1 = 0 ;
41483 char * kwnames[] = {
41484 (char *) "self",(char *) "id", NULL
41485 };
41486
41487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41489 if (!SWIG_IsOK(res1)) {
41490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41491 }
41492 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41493 ecode2 = SWIG_AsVal_int(obj1, &val2);
41494 if (!SWIG_IsOK(ecode2)) {
41495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41496 }
41497 arg2 = static_cast< int >(val2);
41498 {
41499 PyThreadState* __tstate = wxPyBeginAllowThreads();
41500 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41501 wxPyEndAllowThreads(__tstate);
41502 if (PyErr_Occurred()) SWIG_fail;
41503 }
41504 {
41505 #if wxUSE_UNICODE
41506 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41507 #else
41508 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41509 #endif
41510 }
41511 return resultobj;
41512 fail:
41513 return NULL;
41514 }
41515
41516
41517 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41518 PyObject *resultobj = 0;
41519 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41520 int arg2 ;
41521 wxString *arg3 = 0 ;
41522 void *argp1 = 0 ;
41523 int res1 = 0 ;
41524 int val2 ;
41525 int ecode2 = 0 ;
41526 bool temp3 = false ;
41527 PyObject * obj0 = 0 ;
41528 PyObject * obj1 = 0 ;
41529 PyObject * obj2 = 0 ;
41530 char * kwnames[] = {
41531 (char *) "self",(char *) "id",(char *) "helpString", NULL
41532 };
41533
41534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41536 if (!SWIG_IsOK(res1)) {
41537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41538 }
41539 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41540 ecode2 = SWIG_AsVal_int(obj1, &val2);
41541 if (!SWIG_IsOK(ecode2)) {
41542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41543 }
41544 arg2 = static_cast< int >(val2);
41545 {
41546 arg3 = wxString_in_helper(obj2);
41547 if (arg3 == NULL) SWIG_fail;
41548 temp3 = true;
41549 }
41550 {
41551 PyThreadState* __tstate = wxPyBeginAllowThreads();
41552 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41553 wxPyEndAllowThreads(__tstate);
41554 if (PyErr_Occurred()) SWIG_fail;
41555 }
41556 resultobj = SWIG_Py_Void();
41557 {
41558 if (temp3)
41559 delete arg3;
41560 }
41561 return resultobj;
41562 fail:
41563 {
41564 if (temp3)
41565 delete arg3;
41566 }
41567 return NULL;
41568 }
41569
41570
41571 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41572 PyObject *resultobj = 0;
41573 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41574 int arg2 ;
41575 wxString result;
41576 void *argp1 = 0 ;
41577 int res1 = 0 ;
41578 int val2 ;
41579 int ecode2 = 0 ;
41580 PyObject * obj0 = 0 ;
41581 PyObject * obj1 = 0 ;
41582 char * kwnames[] = {
41583 (char *) "self",(char *) "id", NULL
41584 };
41585
41586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41588 if (!SWIG_IsOK(res1)) {
41589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41590 }
41591 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41592 ecode2 = SWIG_AsVal_int(obj1, &val2);
41593 if (!SWIG_IsOK(ecode2)) {
41594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41595 }
41596 arg2 = static_cast< int >(val2);
41597 {
41598 PyThreadState* __tstate = wxPyBeginAllowThreads();
41599 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41600 wxPyEndAllowThreads(__tstate);
41601 if (PyErr_Occurred()) SWIG_fail;
41602 }
41603 {
41604 #if wxUSE_UNICODE
41605 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41606 #else
41607 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41608 #endif
41609 }
41610 return resultobj;
41611 fail:
41612 return NULL;
41613 }
41614
41615
41616 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41617 PyObject *resultobj = 0;
41618 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41619 wxFrame *result = 0 ;
41620 void *argp1 = 0 ;
41621 int res1 = 0 ;
41622 PyObject *swig_obj[1] ;
41623
41624 if (!args) SWIG_fail;
41625 swig_obj[0] = args;
41626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41627 if (!SWIG_IsOK(res1)) {
41628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41629 }
41630 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41631 {
41632 PyThreadState* __tstate = wxPyBeginAllowThreads();
41633 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41634 wxPyEndAllowThreads(__tstate);
41635 if (PyErr_Occurred()) SWIG_fail;
41636 }
41637 {
41638 resultobj = wxPyMake_wxObject(result, (bool)0);
41639 }
41640 return resultobj;
41641 fail:
41642 return NULL;
41643 }
41644
41645
41646 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41647 PyObject *resultobj = 0;
41648 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41649 bool result;
41650 void *argp1 = 0 ;
41651 int res1 = 0 ;
41652 PyObject *swig_obj[1] ;
41653
41654 if (!args) SWIG_fail;
41655 swig_obj[0] = args;
41656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41657 if (!SWIG_IsOK(res1)) {
41658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41659 }
41660 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41661 {
41662 PyThreadState* __tstate = wxPyBeginAllowThreads();
41663 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41664 wxPyEndAllowThreads(__tstate);
41665 if (PyErr_Occurred()) SWIG_fail;
41666 }
41667 {
41668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41669 }
41670 return resultobj;
41671 fail:
41672 return NULL;
41673 }
41674
41675
41676 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41677 PyObject *resultobj = 0;
41678 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41679 wxFrame *arg2 = (wxFrame *) 0 ;
41680 void *argp1 = 0 ;
41681 int res1 = 0 ;
41682 void *argp2 = 0 ;
41683 int res2 = 0 ;
41684 PyObject * obj0 = 0 ;
41685 PyObject * obj1 = 0 ;
41686 char * kwnames[] = {
41687 (char *) "self",(char *) "frame", NULL
41688 };
41689
41690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41692 if (!SWIG_IsOK(res1)) {
41693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41694 }
41695 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41697 if (!SWIG_IsOK(res2)) {
41698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41699 }
41700 arg2 = reinterpret_cast< wxFrame * >(argp2);
41701 {
41702 PyThreadState* __tstate = wxPyBeginAllowThreads();
41703 (arg1)->Attach(arg2);
41704 wxPyEndAllowThreads(__tstate);
41705 if (PyErr_Occurred()) SWIG_fail;
41706 }
41707 resultobj = SWIG_Py_Void();
41708 return resultobj;
41709 fail:
41710 return NULL;
41711 }
41712
41713
41714 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41715 PyObject *resultobj = 0;
41716 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41717 void *argp1 = 0 ;
41718 int res1 = 0 ;
41719 PyObject *swig_obj[1] ;
41720
41721 if (!args) SWIG_fail;
41722 swig_obj[0] = args;
41723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41724 if (!SWIG_IsOK(res1)) {
41725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41726 }
41727 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41728 {
41729 PyThreadState* __tstate = wxPyBeginAllowThreads();
41730 (arg1)->Detach();
41731 wxPyEndAllowThreads(__tstate);
41732 if (PyErr_Occurred()) SWIG_fail;
41733 }
41734 resultobj = SWIG_Py_Void();
41735 return resultobj;
41736 fail:
41737 return NULL;
41738 }
41739
41740
41741 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41742 PyObject *resultobj = 0;
41743 bool arg1 ;
41744 bool val1 ;
41745 int ecode1 = 0 ;
41746 PyObject * obj0 = 0 ;
41747 char * kwnames[] = {
41748 (char *) "enable", NULL
41749 };
41750
41751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41752 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41753 if (!SWIG_IsOK(ecode1)) {
41754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41755 }
41756 arg1 = static_cast< bool >(val1);
41757 {
41758 PyThreadState* __tstate = wxPyBeginAllowThreads();
41759 wxMenuBar::SetAutoWindowMenu(arg1);
41760 wxPyEndAllowThreads(__tstate);
41761 if (PyErr_Occurred()) SWIG_fail;
41762 }
41763 resultobj = SWIG_Py_Void();
41764 return resultobj;
41765 fail:
41766 return NULL;
41767 }
41768
41769
41770 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41771 PyObject *resultobj = 0;
41772 bool result;
41773
41774 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41775 {
41776 PyThreadState* __tstate = wxPyBeginAllowThreads();
41777 result = (bool)wxMenuBar::GetAutoWindowMenu();
41778 wxPyEndAllowThreads(__tstate);
41779 if (PyErr_Occurred()) SWIG_fail;
41780 }
41781 {
41782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41783 }
41784 return resultobj;
41785 fail:
41786 return NULL;
41787 }
41788
41789
41790 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41791 PyObject *obj;
41792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41793 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41794 return SWIG_Py_Void();
41795 }
41796
41797 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41798 return SWIG_Python_InitShadowInstance(args);
41799 }
41800
41801 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41802 PyObject *resultobj = 0;
41803 wxMenu *arg1 = (wxMenu *) NULL ;
41804 int arg2 = (int) wxID_ANY ;
41805 wxString const &arg3_defvalue = wxPyEmptyString ;
41806 wxString *arg3 = (wxString *) &arg3_defvalue ;
41807 wxString const &arg4_defvalue = wxPyEmptyString ;
41808 wxString *arg4 = (wxString *) &arg4_defvalue ;
41809 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41810 wxMenu *arg6 = (wxMenu *) NULL ;
41811 wxMenuItem *result = 0 ;
41812 void *argp1 = 0 ;
41813 int res1 = 0 ;
41814 int val2 ;
41815 int ecode2 = 0 ;
41816 bool temp3 = false ;
41817 bool temp4 = false ;
41818 int val5 ;
41819 int ecode5 = 0 ;
41820 void *argp6 = 0 ;
41821 int res6 = 0 ;
41822 PyObject * obj0 = 0 ;
41823 PyObject * obj1 = 0 ;
41824 PyObject * obj2 = 0 ;
41825 PyObject * obj3 = 0 ;
41826 PyObject * obj4 = 0 ;
41827 PyObject * obj5 = 0 ;
41828 char * kwnames[] = {
41829 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41830 };
41831
41832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41833 if (obj0) {
41834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41835 if (!SWIG_IsOK(res1)) {
41836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41837 }
41838 arg1 = reinterpret_cast< wxMenu * >(argp1);
41839 }
41840 if (obj1) {
41841 ecode2 = SWIG_AsVal_int(obj1, &val2);
41842 if (!SWIG_IsOK(ecode2)) {
41843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41844 }
41845 arg2 = static_cast< int >(val2);
41846 }
41847 if (obj2) {
41848 {
41849 arg3 = wxString_in_helper(obj2);
41850 if (arg3 == NULL) SWIG_fail;
41851 temp3 = true;
41852 }
41853 }
41854 if (obj3) {
41855 {
41856 arg4 = wxString_in_helper(obj3);
41857 if (arg4 == NULL) SWIG_fail;
41858 temp4 = true;
41859 }
41860 }
41861 if (obj4) {
41862 ecode5 = SWIG_AsVal_int(obj4, &val5);
41863 if (!SWIG_IsOK(ecode5)) {
41864 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
41865 }
41866 arg5 = static_cast< wxItemKind >(val5);
41867 }
41868 if (obj5) {
41869 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
41870 if (!SWIG_IsOK(res6)) {
41871 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
41872 }
41873 arg6 = reinterpret_cast< wxMenu * >(argp6);
41874 }
41875 {
41876 PyThreadState* __tstate = wxPyBeginAllowThreads();
41877 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
41878 wxPyEndAllowThreads(__tstate);
41879 if (PyErr_Occurred()) SWIG_fail;
41880 }
41881 {
41882 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
41883 }
41884 {
41885 if (temp3)
41886 delete arg3;
41887 }
41888 {
41889 if (temp4)
41890 delete arg4;
41891 }
41892 return resultobj;
41893 fail:
41894 {
41895 if (temp3)
41896 delete arg3;
41897 }
41898 {
41899 if (temp4)
41900 delete arg4;
41901 }
41902 return NULL;
41903 }
41904
41905
41906 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41907 PyObject *resultobj = 0;
41908 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41909 void *argp1 = 0 ;
41910 int res1 = 0 ;
41911 PyObject *swig_obj[1] ;
41912
41913 if (!args) SWIG_fail;
41914 swig_obj[0] = args;
41915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
41916 if (!SWIG_IsOK(res1)) {
41917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41918 }
41919 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41920 {
41921 PyThreadState* __tstate = wxPyBeginAllowThreads();
41922 delete arg1;
41923
41924 wxPyEndAllowThreads(__tstate);
41925 if (PyErr_Occurred()) SWIG_fail;
41926 }
41927 resultobj = SWIG_Py_Void();
41928 return resultobj;
41929 fail:
41930 return NULL;
41931 }
41932
41933
41934 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41935 PyObject *resultobj = 0;
41936 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41937 wxMenu *result = 0 ;
41938 void *argp1 = 0 ;
41939 int res1 = 0 ;
41940 PyObject *swig_obj[1] ;
41941
41942 if (!args) SWIG_fail;
41943 swig_obj[0] = args;
41944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41945 if (!SWIG_IsOK(res1)) {
41946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41947 }
41948 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41949 {
41950 PyThreadState* __tstate = wxPyBeginAllowThreads();
41951 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
41952 wxPyEndAllowThreads(__tstate);
41953 if (PyErr_Occurred()) SWIG_fail;
41954 }
41955 {
41956 resultobj = wxPyMake_wxObject(result, 0);
41957 }
41958 return resultobj;
41959 fail:
41960 return NULL;
41961 }
41962
41963
41964 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41965 PyObject *resultobj = 0;
41966 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41967 wxMenu *arg2 = (wxMenu *) 0 ;
41968 void *argp1 = 0 ;
41969 int res1 = 0 ;
41970 void *argp2 = 0 ;
41971 int res2 = 0 ;
41972 PyObject * obj0 = 0 ;
41973 PyObject * obj1 = 0 ;
41974 char * kwnames[] = {
41975 (char *) "self",(char *) "menu", NULL
41976 };
41977
41978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41980 if (!SWIG_IsOK(res1)) {
41981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41982 }
41983 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41984 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41985 if (!SWIG_IsOK(res2)) {
41986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
41987 }
41988 arg2 = reinterpret_cast< wxMenu * >(argp2);
41989 {
41990 PyThreadState* __tstate = wxPyBeginAllowThreads();
41991 (arg1)->SetMenu(arg2);
41992 wxPyEndAllowThreads(__tstate);
41993 if (PyErr_Occurred()) SWIG_fail;
41994 }
41995 resultobj = SWIG_Py_Void();
41996 return resultobj;
41997 fail:
41998 return NULL;
41999 }
42000
42001
42002 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42003 PyObject *resultobj = 0;
42004 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42005 int arg2 ;
42006 void *argp1 = 0 ;
42007 int res1 = 0 ;
42008 int val2 ;
42009 int ecode2 = 0 ;
42010 PyObject * obj0 = 0 ;
42011 PyObject * obj1 = 0 ;
42012 char * kwnames[] = {
42013 (char *) "self",(char *) "id", NULL
42014 };
42015
42016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42018 if (!SWIG_IsOK(res1)) {
42019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42020 }
42021 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42022 ecode2 = SWIG_AsVal_int(obj1, &val2);
42023 if (!SWIG_IsOK(ecode2)) {
42024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42025 }
42026 arg2 = static_cast< int >(val2);
42027 {
42028 PyThreadState* __tstate = wxPyBeginAllowThreads();
42029 (arg1)->SetId(arg2);
42030 wxPyEndAllowThreads(__tstate);
42031 if (PyErr_Occurred()) SWIG_fail;
42032 }
42033 resultobj = SWIG_Py_Void();
42034 return resultobj;
42035 fail:
42036 return NULL;
42037 }
42038
42039
42040 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42041 PyObject *resultobj = 0;
42042 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42043 int result;
42044 void *argp1 = 0 ;
42045 int res1 = 0 ;
42046 PyObject *swig_obj[1] ;
42047
42048 if (!args) SWIG_fail;
42049 swig_obj[0] = args;
42050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42051 if (!SWIG_IsOK(res1)) {
42052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42053 }
42054 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42055 {
42056 PyThreadState* __tstate = wxPyBeginAllowThreads();
42057 result = (int)((wxMenuItem const *)arg1)->GetId();
42058 wxPyEndAllowThreads(__tstate);
42059 if (PyErr_Occurred()) SWIG_fail;
42060 }
42061 resultobj = SWIG_From_int(static_cast< int >(result));
42062 return resultobj;
42063 fail:
42064 return NULL;
42065 }
42066
42067
42068 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42069 PyObject *resultobj = 0;
42070 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42071 bool result;
42072 void *argp1 = 0 ;
42073 int res1 = 0 ;
42074 PyObject *swig_obj[1] ;
42075
42076 if (!args) SWIG_fail;
42077 swig_obj[0] = args;
42078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42079 if (!SWIG_IsOK(res1)) {
42080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42081 }
42082 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42083 {
42084 PyThreadState* __tstate = wxPyBeginAllowThreads();
42085 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42086 wxPyEndAllowThreads(__tstate);
42087 if (PyErr_Occurred()) SWIG_fail;
42088 }
42089 {
42090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42091 }
42092 return resultobj;
42093 fail:
42094 return NULL;
42095 }
42096
42097
42098 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42099 PyObject *resultobj = 0;
42100 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42101 wxString *arg2 = 0 ;
42102 void *argp1 = 0 ;
42103 int res1 = 0 ;
42104 bool temp2 = false ;
42105 PyObject * obj0 = 0 ;
42106 PyObject * obj1 = 0 ;
42107 char * kwnames[] = {
42108 (char *) "self",(char *) "str", NULL
42109 };
42110
42111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42113 if (!SWIG_IsOK(res1)) {
42114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42115 }
42116 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42117 {
42118 arg2 = wxString_in_helper(obj1);
42119 if (arg2 == NULL) SWIG_fail;
42120 temp2 = true;
42121 }
42122 {
42123 PyThreadState* __tstate = wxPyBeginAllowThreads();
42124 (arg1)->SetText((wxString const &)*arg2);
42125 wxPyEndAllowThreads(__tstate);
42126 if (PyErr_Occurred()) SWIG_fail;
42127 }
42128 resultobj = SWIG_Py_Void();
42129 {
42130 if (temp2)
42131 delete arg2;
42132 }
42133 return resultobj;
42134 fail:
42135 {
42136 if (temp2)
42137 delete arg2;
42138 }
42139 return NULL;
42140 }
42141
42142
42143 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42144 PyObject *resultobj = 0;
42145 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42146 wxString result;
42147 void *argp1 = 0 ;
42148 int res1 = 0 ;
42149 PyObject *swig_obj[1] ;
42150
42151 if (!args) SWIG_fail;
42152 swig_obj[0] = args;
42153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42154 if (!SWIG_IsOK(res1)) {
42155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42156 }
42157 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42158 {
42159 PyThreadState* __tstate = wxPyBeginAllowThreads();
42160 result = ((wxMenuItem const *)arg1)->GetLabel();
42161 wxPyEndAllowThreads(__tstate);
42162 if (PyErr_Occurred()) SWIG_fail;
42163 }
42164 {
42165 #if wxUSE_UNICODE
42166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42167 #else
42168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42169 #endif
42170 }
42171 return resultobj;
42172 fail:
42173 return NULL;
42174 }
42175
42176
42177 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42178 PyObject *resultobj = 0;
42179 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42180 wxString *result = 0 ;
42181 void *argp1 = 0 ;
42182 int res1 = 0 ;
42183 PyObject *swig_obj[1] ;
42184
42185 if (!args) SWIG_fail;
42186 swig_obj[0] = args;
42187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42188 if (!SWIG_IsOK(res1)) {
42189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42190 }
42191 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42192 {
42193 PyThreadState* __tstate = wxPyBeginAllowThreads();
42194 {
42195 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42196 result = (wxString *) &_result_ref;
42197 }
42198 wxPyEndAllowThreads(__tstate);
42199 if (PyErr_Occurred()) SWIG_fail;
42200 }
42201 {
42202 #if wxUSE_UNICODE
42203 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42204 #else
42205 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42206 #endif
42207 }
42208 return resultobj;
42209 fail:
42210 return NULL;
42211 }
42212
42213
42214 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42215 PyObject *resultobj = 0;
42216 wxString *arg1 = 0 ;
42217 wxString result;
42218 bool temp1 = false ;
42219 PyObject * obj0 = 0 ;
42220 char * kwnames[] = {
42221 (char *) "text", NULL
42222 };
42223
42224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42225 {
42226 arg1 = wxString_in_helper(obj0);
42227 if (arg1 == NULL) SWIG_fail;
42228 temp1 = true;
42229 }
42230 {
42231 PyThreadState* __tstate = wxPyBeginAllowThreads();
42232 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42233 wxPyEndAllowThreads(__tstate);
42234 if (PyErr_Occurred()) SWIG_fail;
42235 }
42236 {
42237 #if wxUSE_UNICODE
42238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42239 #else
42240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42241 #endif
42242 }
42243 {
42244 if (temp1)
42245 delete arg1;
42246 }
42247 return resultobj;
42248 fail:
42249 {
42250 if (temp1)
42251 delete arg1;
42252 }
42253 return NULL;
42254 }
42255
42256
42257 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42258 PyObject *resultobj = 0;
42259 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42260 wxItemKind result;
42261 void *argp1 = 0 ;
42262 int res1 = 0 ;
42263 PyObject *swig_obj[1] ;
42264
42265 if (!args) SWIG_fail;
42266 swig_obj[0] = args;
42267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42268 if (!SWIG_IsOK(res1)) {
42269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42270 }
42271 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42272 {
42273 PyThreadState* __tstate = wxPyBeginAllowThreads();
42274 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42275 wxPyEndAllowThreads(__tstate);
42276 if (PyErr_Occurred()) SWIG_fail;
42277 }
42278 resultobj = SWIG_From_int(static_cast< int >(result));
42279 return resultobj;
42280 fail:
42281 return NULL;
42282 }
42283
42284
42285 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42286 PyObject *resultobj = 0;
42287 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42288 wxItemKind arg2 ;
42289 void *argp1 = 0 ;
42290 int res1 = 0 ;
42291 int val2 ;
42292 int ecode2 = 0 ;
42293 PyObject * obj0 = 0 ;
42294 PyObject * obj1 = 0 ;
42295 char * kwnames[] = {
42296 (char *) "self",(char *) "kind", NULL
42297 };
42298
42299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42301 if (!SWIG_IsOK(res1)) {
42302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42303 }
42304 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42305 ecode2 = SWIG_AsVal_int(obj1, &val2);
42306 if (!SWIG_IsOK(ecode2)) {
42307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42308 }
42309 arg2 = static_cast< wxItemKind >(val2);
42310 {
42311 PyThreadState* __tstate = wxPyBeginAllowThreads();
42312 (arg1)->SetKind(arg2);
42313 wxPyEndAllowThreads(__tstate);
42314 if (PyErr_Occurred()) SWIG_fail;
42315 }
42316 resultobj = SWIG_Py_Void();
42317 return resultobj;
42318 fail:
42319 return NULL;
42320 }
42321
42322
42323 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42324 PyObject *resultobj = 0;
42325 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42326 bool arg2 ;
42327 void *argp1 = 0 ;
42328 int res1 = 0 ;
42329 bool val2 ;
42330 int ecode2 = 0 ;
42331 PyObject * obj0 = 0 ;
42332 PyObject * obj1 = 0 ;
42333 char * kwnames[] = {
42334 (char *) "self",(char *) "checkable", NULL
42335 };
42336
42337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42339 if (!SWIG_IsOK(res1)) {
42340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42341 }
42342 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42343 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42344 if (!SWIG_IsOK(ecode2)) {
42345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42346 }
42347 arg2 = static_cast< bool >(val2);
42348 {
42349 PyThreadState* __tstate = wxPyBeginAllowThreads();
42350 (arg1)->SetCheckable(arg2);
42351 wxPyEndAllowThreads(__tstate);
42352 if (PyErr_Occurred()) SWIG_fail;
42353 }
42354 resultobj = SWIG_Py_Void();
42355 return resultobj;
42356 fail:
42357 return NULL;
42358 }
42359
42360
42361 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42362 PyObject *resultobj = 0;
42363 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42364 bool result;
42365 void *argp1 = 0 ;
42366 int res1 = 0 ;
42367 PyObject *swig_obj[1] ;
42368
42369 if (!args) SWIG_fail;
42370 swig_obj[0] = args;
42371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42372 if (!SWIG_IsOK(res1)) {
42373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42374 }
42375 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42376 {
42377 PyThreadState* __tstate = wxPyBeginAllowThreads();
42378 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42379 wxPyEndAllowThreads(__tstate);
42380 if (PyErr_Occurred()) SWIG_fail;
42381 }
42382 {
42383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42384 }
42385 return resultobj;
42386 fail:
42387 return NULL;
42388 }
42389
42390
42391 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42392 PyObject *resultobj = 0;
42393 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42394 bool result;
42395 void *argp1 = 0 ;
42396 int res1 = 0 ;
42397 PyObject *swig_obj[1] ;
42398
42399 if (!args) SWIG_fail;
42400 swig_obj[0] = args;
42401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42402 if (!SWIG_IsOK(res1)) {
42403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42404 }
42405 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42406 {
42407 PyThreadState* __tstate = wxPyBeginAllowThreads();
42408 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42409 wxPyEndAllowThreads(__tstate);
42410 if (PyErr_Occurred()) SWIG_fail;
42411 }
42412 {
42413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42414 }
42415 return resultobj;
42416 fail:
42417 return NULL;
42418 }
42419
42420
42421 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42422 PyObject *resultobj = 0;
42423 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42424 wxMenu *arg2 = (wxMenu *) 0 ;
42425 void *argp1 = 0 ;
42426 int res1 = 0 ;
42427 void *argp2 = 0 ;
42428 int res2 = 0 ;
42429 PyObject * obj0 = 0 ;
42430 PyObject * obj1 = 0 ;
42431 char * kwnames[] = {
42432 (char *) "self",(char *) "menu", NULL
42433 };
42434
42435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42437 if (!SWIG_IsOK(res1)) {
42438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42439 }
42440 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42441 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42442 if (!SWIG_IsOK(res2)) {
42443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42444 }
42445 arg2 = reinterpret_cast< wxMenu * >(argp2);
42446 {
42447 PyThreadState* __tstate = wxPyBeginAllowThreads();
42448 (arg1)->SetSubMenu(arg2);
42449 wxPyEndAllowThreads(__tstate);
42450 if (PyErr_Occurred()) SWIG_fail;
42451 }
42452 resultobj = SWIG_Py_Void();
42453 return resultobj;
42454 fail:
42455 return NULL;
42456 }
42457
42458
42459 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42460 PyObject *resultobj = 0;
42461 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42462 wxMenu *result = 0 ;
42463 void *argp1 = 0 ;
42464 int res1 = 0 ;
42465 PyObject *swig_obj[1] ;
42466
42467 if (!args) SWIG_fail;
42468 swig_obj[0] = args;
42469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42470 if (!SWIG_IsOK(res1)) {
42471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42472 }
42473 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42474 {
42475 PyThreadState* __tstate = wxPyBeginAllowThreads();
42476 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42477 wxPyEndAllowThreads(__tstate);
42478 if (PyErr_Occurred()) SWIG_fail;
42479 }
42480 {
42481 resultobj = wxPyMake_wxObject(result, 0);
42482 }
42483 return resultobj;
42484 fail:
42485 return NULL;
42486 }
42487
42488
42489 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42490 PyObject *resultobj = 0;
42491 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42492 bool arg2 = (bool) true ;
42493 void *argp1 = 0 ;
42494 int res1 = 0 ;
42495 bool val2 ;
42496 int ecode2 = 0 ;
42497 PyObject * obj0 = 0 ;
42498 PyObject * obj1 = 0 ;
42499 char * kwnames[] = {
42500 (char *) "self",(char *) "enable", NULL
42501 };
42502
42503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42505 if (!SWIG_IsOK(res1)) {
42506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42507 }
42508 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42509 if (obj1) {
42510 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42511 if (!SWIG_IsOK(ecode2)) {
42512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42513 }
42514 arg2 = static_cast< bool >(val2);
42515 }
42516 {
42517 PyThreadState* __tstate = wxPyBeginAllowThreads();
42518 (arg1)->Enable(arg2);
42519 wxPyEndAllowThreads(__tstate);
42520 if (PyErr_Occurred()) SWIG_fail;
42521 }
42522 resultobj = SWIG_Py_Void();
42523 return resultobj;
42524 fail:
42525 return NULL;
42526 }
42527
42528
42529 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42530 PyObject *resultobj = 0;
42531 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42532 bool result;
42533 void *argp1 = 0 ;
42534 int res1 = 0 ;
42535 PyObject *swig_obj[1] ;
42536
42537 if (!args) SWIG_fail;
42538 swig_obj[0] = args;
42539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42540 if (!SWIG_IsOK(res1)) {
42541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42542 }
42543 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42544 {
42545 PyThreadState* __tstate = wxPyBeginAllowThreads();
42546 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42547 wxPyEndAllowThreads(__tstate);
42548 if (PyErr_Occurred()) SWIG_fail;
42549 }
42550 {
42551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42552 }
42553 return resultobj;
42554 fail:
42555 return NULL;
42556 }
42557
42558
42559 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42560 PyObject *resultobj = 0;
42561 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42562 bool arg2 = (bool) true ;
42563 void *argp1 = 0 ;
42564 int res1 = 0 ;
42565 bool val2 ;
42566 int ecode2 = 0 ;
42567 PyObject * obj0 = 0 ;
42568 PyObject * obj1 = 0 ;
42569 char * kwnames[] = {
42570 (char *) "self",(char *) "check", NULL
42571 };
42572
42573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42575 if (!SWIG_IsOK(res1)) {
42576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42577 }
42578 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42579 if (obj1) {
42580 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42581 if (!SWIG_IsOK(ecode2)) {
42582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42583 }
42584 arg2 = static_cast< bool >(val2);
42585 }
42586 {
42587 PyThreadState* __tstate = wxPyBeginAllowThreads();
42588 (arg1)->Check(arg2);
42589 wxPyEndAllowThreads(__tstate);
42590 if (PyErr_Occurred()) SWIG_fail;
42591 }
42592 resultobj = SWIG_Py_Void();
42593 return resultobj;
42594 fail:
42595 return NULL;
42596 }
42597
42598
42599 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42600 PyObject *resultobj = 0;
42601 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42602 bool result;
42603 void *argp1 = 0 ;
42604 int res1 = 0 ;
42605 PyObject *swig_obj[1] ;
42606
42607 if (!args) SWIG_fail;
42608 swig_obj[0] = args;
42609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42610 if (!SWIG_IsOK(res1)) {
42611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42612 }
42613 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42614 {
42615 PyThreadState* __tstate = wxPyBeginAllowThreads();
42616 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42617 wxPyEndAllowThreads(__tstate);
42618 if (PyErr_Occurred()) SWIG_fail;
42619 }
42620 {
42621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42622 }
42623 return resultobj;
42624 fail:
42625 return NULL;
42626 }
42627
42628
42629 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42630 PyObject *resultobj = 0;
42631 wxMenuItem *arg1 = (wxMenuItem *) 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_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42641 }
42642 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42643 {
42644 PyThreadState* __tstate = wxPyBeginAllowThreads();
42645 (arg1)->Toggle();
42646 wxPyEndAllowThreads(__tstate);
42647 if (PyErr_Occurred()) SWIG_fail;
42648 }
42649 resultobj = SWIG_Py_Void();
42650 return resultobj;
42651 fail:
42652 return NULL;
42653 }
42654
42655
42656 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42657 PyObject *resultobj = 0;
42658 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42659 wxString *arg2 = 0 ;
42660 void *argp1 = 0 ;
42661 int res1 = 0 ;
42662 bool temp2 = false ;
42663 PyObject * obj0 = 0 ;
42664 PyObject * obj1 = 0 ;
42665 char * kwnames[] = {
42666 (char *) "self",(char *) "str", NULL
42667 };
42668
42669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42671 if (!SWIG_IsOK(res1)) {
42672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42673 }
42674 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42675 {
42676 arg2 = wxString_in_helper(obj1);
42677 if (arg2 == NULL) SWIG_fail;
42678 temp2 = true;
42679 }
42680 {
42681 PyThreadState* __tstate = wxPyBeginAllowThreads();
42682 (arg1)->SetHelp((wxString const &)*arg2);
42683 wxPyEndAllowThreads(__tstate);
42684 if (PyErr_Occurred()) SWIG_fail;
42685 }
42686 resultobj = SWIG_Py_Void();
42687 {
42688 if (temp2)
42689 delete arg2;
42690 }
42691 return resultobj;
42692 fail:
42693 {
42694 if (temp2)
42695 delete arg2;
42696 }
42697 return NULL;
42698 }
42699
42700
42701 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42702 PyObject *resultobj = 0;
42703 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42704 wxString *result = 0 ;
42705 void *argp1 = 0 ;
42706 int res1 = 0 ;
42707 PyObject *swig_obj[1] ;
42708
42709 if (!args) SWIG_fail;
42710 swig_obj[0] = args;
42711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42712 if (!SWIG_IsOK(res1)) {
42713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42714 }
42715 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42716 {
42717 PyThreadState* __tstate = wxPyBeginAllowThreads();
42718 {
42719 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42720 result = (wxString *) &_result_ref;
42721 }
42722 wxPyEndAllowThreads(__tstate);
42723 if (PyErr_Occurred()) SWIG_fail;
42724 }
42725 {
42726 #if wxUSE_UNICODE
42727 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42728 #else
42729 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42730 #endif
42731 }
42732 return resultobj;
42733 fail:
42734 return NULL;
42735 }
42736
42737
42738 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42739 PyObject *resultobj = 0;
42740 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42741 wxAcceleratorEntry *result = 0 ;
42742 void *argp1 = 0 ;
42743 int res1 = 0 ;
42744 PyObject *swig_obj[1] ;
42745
42746 if (!args) SWIG_fail;
42747 swig_obj[0] = args;
42748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42749 if (!SWIG_IsOK(res1)) {
42750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42751 }
42752 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42753 {
42754 PyThreadState* __tstate = wxPyBeginAllowThreads();
42755 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42756 wxPyEndAllowThreads(__tstate);
42757 if (PyErr_Occurred()) SWIG_fail;
42758 }
42759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42760 return resultobj;
42761 fail:
42762 return NULL;
42763 }
42764
42765
42766 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42767 PyObject *resultobj = 0;
42768 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42769 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42770 void *argp1 = 0 ;
42771 int res1 = 0 ;
42772 void *argp2 = 0 ;
42773 int res2 = 0 ;
42774 PyObject * obj0 = 0 ;
42775 PyObject * obj1 = 0 ;
42776 char * kwnames[] = {
42777 (char *) "self",(char *) "accel", NULL
42778 };
42779
42780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42782 if (!SWIG_IsOK(res1)) {
42783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42784 }
42785 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42787 if (!SWIG_IsOK(res2)) {
42788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42789 }
42790 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42791 {
42792 PyThreadState* __tstate = wxPyBeginAllowThreads();
42793 (arg1)->SetAccel(arg2);
42794 wxPyEndAllowThreads(__tstate);
42795 if (PyErr_Occurred()) SWIG_fail;
42796 }
42797 resultobj = SWIG_Py_Void();
42798 return resultobj;
42799 fail:
42800 return NULL;
42801 }
42802
42803
42804 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42805 PyObject *resultobj = 0;
42806 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42807 wxBitmap *arg2 = 0 ;
42808 void *argp1 = 0 ;
42809 int res1 = 0 ;
42810 void *argp2 = 0 ;
42811 int res2 = 0 ;
42812 PyObject * obj0 = 0 ;
42813 PyObject * obj1 = 0 ;
42814 char * kwnames[] = {
42815 (char *) "self",(char *) "bitmap", NULL
42816 };
42817
42818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42820 if (!SWIG_IsOK(res1)) {
42821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42822 }
42823 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42824 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42825 if (!SWIG_IsOK(res2)) {
42826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42827 }
42828 if (!argp2) {
42829 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42830 }
42831 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42832 {
42833 PyThreadState* __tstate = wxPyBeginAllowThreads();
42834 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42835 wxPyEndAllowThreads(__tstate);
42836 if (PyErr_Occurred()) SWIG_fail;
42837 }
42838 resultobj = SWIG_Py_Void();
42839 return resultobj;
42840 fail:
42841 return NULL;
42842 }
42843
42844
42845 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42846 PyObject *resultobj = 0;
42847 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42848 wxBitmap *result = 0 ;
42849 void *argp1 = 0 ;
42850 int res1 = 0 ;
42851 PyObject *swig_obj[1] ;
42852
42853 if (!args) SWIG_fail;
42854 swig_obj[0] = args;
42855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42856 if (!SWIG_IsOK(res1)) {
42857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42858 }
42859 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42860 {
42861 PyThreadState* __tstate = wxPyBeginAllowThreads();
42862 {
42863 wxBitmap const &_result_ref = (arg1)->GetBitmap();
42864 result = (wxBitmap *) &_result_ref;
42865 }
42866 wxPyEndAllowThreads(__tstate);
42867 if (PyErr_Occurred()) SWIG_fail;
42868 }
42869 {
42870 wxBitmap* resultptr = new wxBitmap(*result);
42871 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
42872 }
42873 return resultobj;
42874 fail:
42875 return NULL;
42876 }
42877
42878
42879 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42880 PyObject *resultobj = 0;
42881 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42882 wxFont *arg2 = 0 ;
42883 void *argp1 = 0 ;
42884 int res1 = 0 ;
42885 void *argp2 = 0 ;
42886 int res2 = 0 ;
42887 PyObject * obj0 = 0 ;
42888 PyObject * obj1 = 0 ;
42889 char * kwnames[] = {
42890 (char *) "self",(char *) "font", NULL
42891 };
42892
42893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
42894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42895 if (!SWIG_IsOK(res1)) {
42896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42897 }
42898 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42899 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
42900 if (!SWIG_IsOK(res2)) {
42901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42902 }
42903 if (!argp2) {
42904 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42905 }
42906 arg2 = reinterpret_cast< wxFont * >(argp2);
42907 {
42908 PyThreadState* __tstate = wxPyBeginAllowThreads();
42909 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
42910 wxPyEndAllowThreads(__tstate);
42911 if (PyErr_Occurred()) SWIG_fail;
42912 }
42913 resultobj = SWIG_Py_Void();
42914 return resultobj;
42915 fail:
42916 return NULL;
42917 }
42918
42919
42920 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42921 PyObject *resultobj = 0;
42922 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42923 wxFont result;
42924 void *argp1 = 0 ;
42925 int res1 = 0 ;
42926 PyObject *swig_obj[1] ;
42927
42928 if (!args) SWIG_fail;
42929 swig_obj[0] = args;
42930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42931 if (!SWIG_IsOK(res1)) {
42932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42933 }
42934 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42935 {
42936 PyThreadState* __tstate = wxPyBeginAllowThreads();
42937 result = wxMenuItem_GetFont(arg1);
42938 wxPyEndAllowThreads(__tstate);
42939 if (PyErr_Occurred()) SWIG_fail;
42940 }
42941 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
42942 return resultobj;
42943 fail:
42944 return NULL;
42945 }
42946
42947
42948 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42949 PyObject *resultobj = 0;
42950 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42951 wxColour *arg2 = 0 ;
42952 void *argp1 = 0 ;
42953 int res1 = 0 ;
42954 wxColour temp2 ;
42955 PyObject * obj0 = 0 ;
42956 PyObject * obj1 = 0 ;
42957 char * kwnames[] = {
42958 (char *) "self",(char *) "colText", NULL
42959 };
42960
42961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
42962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42963 if (!SWIG_IsOK(res1)) {
42964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42965 }
42966 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42967 {
42968 arg2 = &temp2;
42969 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
42970 }
42971 {
42972 PyThreadState* __tstate = wxPyBeginAllowThreads();
42973 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
42974 wxPyEndAllowThreads(__tstate);
42975 if (PyErr_Occurred()) SWIG_fail;
42976 }
42977 resultobj = SWIG_Py_Void();
42978 return resultobj;
42979 fail:
42980 return NULL;
42981 }
42982
42983
42984 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42985 PyObject *resultobj = 0;
42986 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42987 wxColour result;
42988 void *argp1 = 0 ;
42989 int res1 = 0 ;
42990 PyObject *swig_obj[1] ;
42991
42992 if (!args) SWIG_fail;
42993 swig_obj[0] = args;
42994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42995 if (!SWIG_IsOK(res1)) {
42996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42997 }
42998 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42999 {
43000 PyThreadState* __tstate = wxPyBeginAllowThreads();
43001 result = wxMenuItem_GetTextColour(arg1);
43002 wxPyEndAllowThreads(__tstate);
43003 if (PyErr_Occurred()) SWIG_fail;
43004 }
43005 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43006 return resultobj;
43007 fail:
43008 return NULL;
43009 }
43010
43011
43012 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43013 PyObject *resultobj = 0;
43014 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43015 wxColour *arg2 = 0 ;
43016 void *argp1 = 0 ;
43017 int res1 = 0 ;
43018 wxColour temp2 ;
43019 PyObject * obj0 = 0 ;
43020 PyObject * obj1 = 0 ;
43021 char * kwnames[] = {
43022 (char *) "self",(char *) "colBack", NULL
43023 };
43024
43025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43027 if (!SWIG_IsOK(res1)) {
43028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43029 }
43030 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43031 {
43032 arg2 = &temp2;
43033 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43034 }
43035 {
43036 PyThreadState* __tstate = wxPyBeginAllowThreads();
43037 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43038 wxPyEndAllowThreads(__tstate);
43039 if (PyErr_Occurred()) SWIG_fail;
43040 }
43041 resultobj = SWIG_Py_Void();
43042 return resultobj;
43043 fail:
43044 return NULL;
43045 }
43046
43047
43048 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43049 PyObject *resultobj = 0;
43050 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43051 wxColour result;
43052 void *argp1 = 0 ;
43053 int res1 = 0 ;
43054 PyObject *swig_obj[1] ;
43055
43056 if (!args) SWIG_fail;
43057 swig_obj[0] = args;
43058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43059 if (!SWIG_IsOK(res1)) {
43060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43061 }
43062 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43063 {
43064 PyThreadState* __tstate = wxPyBeginAllowThreads();
43065 result = wxMenuItem_GetBackgroundColour(arg1);
43066 wxPyEndAllowThreads(__tstate);
43067 if (PyErr_Occurred()) SWIG_fail;
43068 }
43069 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43070 return resultobj;
43071 fail:
43072 return NULL;
43073 }
43074
43075
43076 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43077 PyObject *resultobj = 0;
43078 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43079 wxBitmap *arg2 = 0 ;
43080 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43081 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43082 void *argp1 = 0 ;
43083 int res1 = 0 ;
43084 void *argp2 = 0 ;
43085 int res2 = 0 ;
43086 void *argp3 = 0 ;
43087 int res3 = 0 ;
43088 PyObject * obj0 = 0 ;
43089 PyObject * obj1 = 0 ;
43090 PyObject * obj2 = 0 ;
43091 char * kwnames[] = {
43092 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43093 };
43094
43095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43097 if (!SWIG_IsOK(res1)) {
43098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43099 }
43100 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43101 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43102 if (!SWIG_IsOK(res2)) {
43103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43104 }
43105 if (!argp2) {
43106 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43107 }
43108 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43109 if (obj2) {
43110 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43111 if (!SWIG_IsOK(res3)) {
43112 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43113 }
43114 if (!argp3) {
43115 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43116 }
43117 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43118 }
43119 {
43120 PyThreadState* __tstate = wxPyBeginAllowThreads();
43121 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43122 wxPyEndAllowThreads(__tstate);
43123 if (PyErr_Occurred()) SWIG_fail;
43124 }
43125 resultobj = SWIG_Py_Void();
43126 return resultobj;
43127 fail:
43128 return NULL;
43129 }
43130
43131
43132 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43133 PyObject *resultobj = 0;
43134 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43135 wxBitmap *arg2 = 0 ;
43136 void *argp1 = 0 ;
43137 int res1 = 0 ;
43138 void *argp2 = 0 ;
43139 int res2 = 0 ;
43140 PyObject * obj0 = 0 ;
43141 PyObject * obj1 = 0 ;
43142 char * kwnames[] = {
43143 (char *) "self",(char *) "bmpDisabled", NULL
43144 };
43145
43146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43148 if (!SWIG_IsOK(res1)) {
43149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43150 }
43151 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43152 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43153 if (!SWIG_IsOK(res2)) {
43154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43155 }
43156 if (!argp2) {
43157 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43158 }
43159 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43160 {
43161 PyThreadState* __tstate = wxPyBeginAllowThreads();
43162 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43163 wxPyEndAllowThreads(__tstate);
43164 if (PyErr_Occurred()) SWIG_fail;
43165 }
43166 resultobj = SWIG_Py_Void();
43167 return resultobj;
43168 fail:
43169 return NULL;
43170 }
43171
43172
43173 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43174 PyObject *resultobj = 0;
43175 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43176 wxBitmap *result = 0 ;
43177 void *argp1 = 0 ;
43178 int res1 = 0 ;
43179 PyObject *swig_obj[1] ;
43180
43181 if (!args) SWIG_fail;
43182 swig_obj[0] = args;
43183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43184 if (!SWIG_IsOK(res1)) {
43185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43186 }
43187 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43188 {
43189 PyThreadState* __tstate = wxPyBeginAllowThreads();
43190 {
43191 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43192 result = (wxBitmap *) &_result_ref;
43193 }
43194 wxPyEndAllowThreads(__tstate);
43195 if (PyErr_Occurred()) SWIG_fail;
43196 }
43197 {
43198 wxBitmap* resultptr = new wxBitmap(*result);
43199 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43200 }
43201 return resultobj;
43202 fail:
43203 return NULL;
43204 }
43205
43206
43207 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43208 PyObject *resultobj = 0;
43209 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43210 int arg2 ;
43211 void *argp1 = 0 ;
43212 int res1 = 0 ;
43213 int val2 ;
43214 int ecode2 = 0 ;
43215 PyObject * obj0 = 0 ;
43216 PyObject * obj1 = 0 ;
43217 char * kwnames[] = {
43218 (char *) "self",(char *) "nWidth", NULL
43219 };
43220
43221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43223 if (!SWIG_IsOK(res1)) {
43224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43225 }
43226 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43227 ecode2 = SWIG_AsVal_int(obj1, &val2);
43228 if (!SWIG_IsOK(ecode2)) {
43229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43230 }
43231 arg2 = static_cast< int >(val2);
43232 {
43233 PyThreadState* __tstate = wxPyBeginAllowThreads();
43234 wxMenuItem_SetMarginWidth(arg1,arg2);
43235 wxPyEndAllowThreads(__tstate);
43236 if (PyErr_Occurred()) SWIG_fail;
43237 }
43238 resultobj = SWIG_Py_Void();
43239 return resultobj;
43240 fail:
43241 return NULL;
43242 }
43243
43244
43245 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43246 PyObject *resultobj = 0;
43247 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43248 int result;
43249 void *argp1 = 0 ;
43250 int res1 = 0 ;
43251 PyObject *swig_obj[1] ;
43252
43253 if (!args) SWIG_fail;
43254 swig_obj[0] = args;
43255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43256 if (!SWIG_IsOK(res1)) {
43257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43258 }
43259 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43260 {
43261 PyThreadState* __tstate = wxPyBeginAllowThreads();
43262 result = (int)wxMenuItem_GetMarginWidth(arg1);
43263 wxPyEndAllowThreads(__tstate);
43264 if (PyErr_Occurred()) SWIG_fail;
43265 }
43266 resultobj = SWIG_From_int(static_cast< int >(result));
43267 return resultobj;
43268 fail:
43269 return NULL;
43270 }
43271
43272
43273 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43274 PyObject *resultobj = 0;
43275 int result;
43276
43277 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43278 {
43279 PyThreadState* __tstate = wxPyBeginAllowThreads();
43280 result = (int)wxMenuItem_GetDefaultMarginWidth();
43281 wxPyEndAllowThreads(__tstate);
43282 if (PyErr_Occurred()) SWIG_fail;
43283 }
43284 resultobj = SWIG_From_int(static_cast< int >(result));
43285 return resultobj;
43286 fail:
43287 return NULL;
43288 }
43289
43290
43291 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43292 PyObject *resultobj = 0;
43293 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43294 bool result;
43295 void *argp1 = 0 ;
43296 int res1 = 0 ;
43297 PyObject *swig_obj[1] ;
43298
43299 if (!args) SWIG_fail;
43300 swig_obj[0] = args;
43301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43302 if (!SWIG_IsOK(res1)) {
43303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43304 }
43305 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43306 {
43307 PyThreadState* __tstate = wxPyBeginAllowThreads();
43308 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43309 wxPyEndAllowThreads(__tstate);
43310 if (PyErr_Occurred()) SWIG_fail;
43311 }
43312 {
43313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43314 }
43315 return resultobj;
43316 fail:
43317 return NULL;
43318 }
43319
43320
43321 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43322 PyObject *resultobj = 0;
43323 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43324 bool arg2 = (bool) true ;
43325 void *argp1 = 0 ;
43326 int res1 = 0 ;
43327 bool val2 ;
43328 int ecode2 = 0 ;
43329 PyObject * obj0 = 0 ;
43330 PyObject * obj1 = 0 ;
43331 char * kwnames[] = {
43332 (char *) "self",(char *) "ownerDrawn", NULL
43333 };
43334
43335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43337 if (!SWIG_IsOK(res1)) {
43338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43339 }
43340 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43341 if (obj1) {
43342 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43343 if (!SWIG_IsOK(ecode2)) {
43344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43345 }
43346 arg2 = static_cast< bool >(val2);
43347 }
43348 {
43349 PyThreadState* __tstate = wxPyBeginAllowThreads();
43350 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43351 wxPyEndAllowThreads(__tstate);
43352 if (PyErr_Occurred()) SWIG_fail;
43353 }
43354 resultobj = SWIG_Py_Void();
43355 return resultobj;
43356 fail:
43357 return NULL;
43358 }
43359
43360
43361 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43362 PyObject *resultobj = 0;
43363 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43364 void *argp1 = 0 ;
43365 int res1 = 0 ;
43366 PyObject *swig_obj[1] ;
43367
43368 if (!args) SWIG_fail;
43369 swig_obj[0] = args;
43370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43371 if (!SWIG_IsOK(res1)) {
43372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43373 }
43374 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43375 {
43376 PyThreadState* __tstate = wxPyBeginAllowThreads();
43377 wxMenuItem_ResetOwnerDrawn(arg1);
43378 wxPyEndAllowThreads(__tstate);
43379 if (PyErr_Occurred()) SWIG_fail;
43380 }
43381 resultobj = SWIG_Py_Void();
43382 return resultobj;
43383 fail:
43384 return NULL;
43385 }
43386
43387
43388 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43389 PyObject *obj;
43390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43391 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43392 return SWIG_Py_Void();
43393 }
43394
43395 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43396 return SWIG_Python_InitShadowInstance(args);
43397 }
43398
43399 SWIGINTERN int ControlNameStr_set(PyObject *) {
43400 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43401 return 1;
43402 }
43403
43404
43405 SWIGINTERN PyObject *ControlNameStr_get(void) {
43406 PyObject *pyobj = 0;
43407
43408 {
43409 #if wxUSE_UNICODE
43410 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43411 #else
43412 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43413 #endif
43414 }
43415 return pyobj;
43416 }
43417
43418
43419 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43420 PyObject *resultobj = 0;
43421 wxWindow *arg1 = (wxWindow *) 0 ;
43422 int arg2 = (int) -1 ;
43423 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43424 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43425 wxSize const &arg4_defvalue = wxDefaultSize ;
43426 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43427 long arg5 = (long) 0 ;
43428 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43429 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43430 wxString const &arg7_defvalue = wxPyControlNameStr ;
43431 wxString *arg7 = (wxString *) &arg7_defvalue ;
43432 wxControl *result = 0 ;
43433 void *argp1 = 0 ;
43434 int res1 = 0 ;
43435 int val2 ;
43436 int ecode2 = 0 ;
43437 wxPoint temp3 ;
43438 wxSize temp4 ;
43439 long val5 ;
43440 int ecode5 = 0 ;
43441 void *argp6 = 0 ;
43442 int res6 = 0 ;
43443 bool temp7 = false ;
43444 PyObject * obj0 = 0 ;
43445 PyObject * obj1 = 0 ;
43446 PyObject * obj2 = 0 ;
43447 PyObject * obj3 = 0 ;
43448 PyObject * obj4 = 0 ;
43449 PyObject * obj5 = 0 ;
43450 PyObject * obj6 = 0 ;
43451 char * kwnames[] = {
43452 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43453 };
43454
43455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43457 if (!SWIG_IsOK(res1)) {
43458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43459 }
43460 arg1 = reinterpret_cast< wxWindow * >(argp1);
43461 if (obj1) {
43462 ecode2 = SWIG_AsVal_int(obj1, &val2);
43463 if (!SWIG_IsOK(ecode2)) {
43464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43465 }
43466 arg2 = static_cast< int >(val2);
43467 }
43468 if (obj2) {
43469 {
43470 arg3 = &temp3;
43471 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43472 }
43473 }
43474 if (obj3) {
43475 {
43476 arg4 = &temp4;
43477 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43478 }
43479 }
43480 if (obj4) {
43481 ecode5 = SWIG_AsVal_long(obj4, &val5);
43482 if (!SWIG_IsOK(ecode5)) {
43483 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43484 }
43485 arg5 = static_cast< long >(val5);
43486 }
43487 if (obj5) {
43488 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43489 if (!SWIG_IsOK(res6)) {
43490 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43491 }
43492 if (!argp6) {
43493 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43494 }
43495 arg6 = reinterpret_cast< wxValidator * >(argp6);
43496 }
43497 if (obj6) {
43498 {
43499 arg7 = wxString_in_helper(obj6);
43500 if (arg7 == NULL) SWIG_fail;
43501 temp7 = true;
43502 }
43503 }
43504 {
43505 if (!wxPyCheckForApp()) SWIG_fail;
43506 PyThreadState* __tstate = wxPyBeginAllowThreads();
43507 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43508 wxPyEndAllowThreads(__tstate);
43509 if (PyErr_Occurred()) SWIG_fail;
43510 }
43511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43512 {
43513 if (temp7)
43514 delete arg7;
43515 }
43516 return resultobj;
43517 fail:
43518 {
43519 if (temp7)
43520 delete arg7;
43521 }
43522 return NULL;
43523 }
43524
43525
43526 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43527 PyObject *resultobj = 0;
43528 wxControl *result = 0 ;
43529
43530 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43531 {
43532 if (!wxPyCheckForApp()) SWIG_fail;
43533 PyThreadState* __tstate = wxPyBeginAllowThreads();
43534 result = (wxControl *)new wxControl();
43535 wxPyEndAllowThreads(__tstate);
43536 if (PyErr_Occurred()) SWIG_fail;
43537 }
43538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43539 return resultobj;
43540 fail:
43541 return NULL;
43542 }
43543
43544
43545 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43546 PyObject *resultobj = 0;
43547 wxControl *arg1 = (wxControl *) 0 ;
43548 wxWindow *arg2 = (wxWindow *) 0 ;
43549 int arg3 = (int) -1 ;
43550 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43551 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43552 wxSize const &arg5_defvalue = wxDefaultSize ;
43553 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43554 long arg6 = (long) 0 ;
43555 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43556 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43557 wxString const &arg8_defvalue = wxPyControlNameStr ;
43558 wxString *arg8 = (wxString *) &arg8_defvalue ;
43559 bool result;
43560 void *argp1 = 0 ;
43561 int res1 = 0 ;
43562 void *argp2 = 0 ;
43563 int res2 = 0 ;
43564 int val3 ;
43565 int ecode3 = 0 ;
43566 wxPoint temp4 ;
43567 wxSize temp5 ;
43568 long val6 ;
43569 int ecode6 = 0 ;
43570 void *argp7 = 0 ;
43571 int res7 = 0 ;
43572 bool temp8 = false ;
43573 PyObject * obj0 = 0 ;
43574 PyObject * obj1 = 0 ;
43575 PyObject * obj2 = 0 ;
43576 PyObject * obj3 = 0 ;
43577 PyObject * obj4 = 0 ;
43578 PyObject * obj5 = 0 ;
43579 PyObject * obj6 = 0 ;
43580 PyObject * obj7 = 0 ;
43581 char * kwnames[] = {
43582 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43583 };
43584
43585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43587 if (!SWIG_IsOK(res1)) {
43588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43589 }
43590 arg1 = reinterpret_cast< wxControl * >(argp1);
43591 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43592 if (!SWIG_IsOK(res2)) {
43593 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43594 }
43595 arg2 = reinterpret_cast< wxWindow * >(argp2);
43596 if (obj2) {
43597 ecode3 = SWIG_AsVal_int(obj2, &val3);
43598 if (!SWIG_IsOK(ecode3)) {
43599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43600 }
43601 arg3 = static_cast< int >(val3);
43602 }
43603 if (obj3) {
43604 {
43605 arg4 = &temp4;
43606 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43607 }
43608 }
43609 if (obj4) {
43610 {
43611 arg5 = &temp5;
43612 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43613 }
43614 }
43615 if (obj5) {
43616 ecode6 = SWIG_AsVal_long(obj5, &val6);
43617 if (!SWIG_IsOK(ecode6)) {
43618 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43619 }
43620 arg6 = static_cast< long >(val6);
43621 }
43622 if (obj6) {
43623 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43624 if (!SWIG_IsOK(res7)) {
43625 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43626 }
43627 if (!argp7) {
43628 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43629 }
43630 arg7 = reinterpret_cast< wxValidator * >(argp7);
43631 }
43632 if (obj7) {
43633 {
43634 arg8 = wxString_in_helper(obj7);
43635 if (arg8 == NULL) SWIG_fail;
43636 temp8 = true;
43637 }
43638 }
43639 {
43640 PyThreadState* __tstate = wxPyBeginAllowThreads();
43641 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43642 wxPyEndAllowThreads(__tstate);
43643 if (PyErr_Occurred()) SWIG_fail;
43644 }
43645 {
43646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43647 }
43648 {
43649 if (temp8)
43650 delete arg8;
43651 }
43652 return resultobj;
43653 fail:
43654 {
43655 if (temp8)
43656 delete arg8;
43657 }
43658 return NULL;
43659 }
43660
43661
43662 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43663 PyObject *resultobj = 0;
43664 wxControl *arg1 = (wxControl *) 0 ;
43665 wxCommandEvent *arg2 = 0 ;
43666 void *argp1 = 0 ;
43667 int res1 = 0 ;
43668 void *argp2 = 0 ;
43669 int res2 = 0 ;
43670 PyObject * obj0 = 0 ;
43671 PyObject * obj1 = 0 ;
43672 char * kwnames[] = {
43673 (char *) "self",(char *) "event", NULL
43674 };
43675
43676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43678 if (!SWIG_IsOK(res1)) {
43679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43680 }
43681 arg1 = reinterpret_cast< wxControl * >(argp1);
43682 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43683 if (!SWIG_IsOK(res2)) {
43684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43685 }
43686 if (!argp2) {
43687 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43688 }
43689 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43690 {
43691 PyThreadState* __tstate = wxPyBeginAllowThreads();
43692 (arg1)->Command(*arg2);
43693 wxPyEndAllowThreads(__tstate);
43694 if (PyErr_Occurred()) SWIG_fail;
43695 }
43696 resultobj = SWIG_Py_Void();
43697 return resultobj;
43698 fail:
43699 return NULL;
43700 }
43701
43702
43703 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43704 PyObject *resultobj = 0;
43705 wxControl *arg1 = (wxControl *) 0 ;
43706 wxString result;
43707 void *argp1 = 0 ;
43708 int res1 = 0 ;
43709 PyObject *swig_obj[1] ;
43710
43711 if (!args) SWIG_fail;
43712 swig_obj[0] = args;
43713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43714 if (!SWIG_IsOK(res1)) {
43715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43716 }
43717 arg1 = reinterpret_cast< wxControl * >(argp1);
43718 {
43719 PyThreadState* __tstate = wxPyBeginAllowThreads();
43720 result = (arg1)->GetLabel();
43721 wxPyEndAllowThreads(__tstate);
43722 if (PyErr_Occurred()) SWIG_fail;
43723 }
43724 {
43725 #if wxUSE_UNICODE
43726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43727 #else
43728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43729 #endif
43730 }
43731 return resultobj;
43732 fail:
43733 return NULL;
43734 }
43735
43736
43737 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43738 PyObject *resultobj = 0;
43739 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43740 SwigValueWrapper<wxVisualAttributes > result;
43741 int val1 ;
43742 int ecode1 = 0 ;
43743 PyObject * obj0 = 0 ;
43744 char * kwnames[] = {
43745 (char *) "variant", NULL
43746 };
43747
43748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43749 if (obj0) {
43750 ecode1 = SWIG_AsVal_int(obj0, &val1);
43751 if (!SWIG_IsOK(ecode1)) {
43752 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43753 }
43754 arg1 = static_cast< wxWindowVariant >(val1);
43755 }
43756 {
43757 if (!wxPyCheckForApp()) SWIG_fail;
43758 PyThreadState* __tstate = wxPyBeginAllowThreads();
43759 result = wxControl::GetClassDefaultAttributes(arg1);
43760 wxPyEndAllowThreads(__tstate);
43761 if (PyErr_Occurred()) SWIG_fail;
43762 }
43763 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43764 return resultobj;
43765 fail:
43766 return NULL;
43767 }
43768
43769
43770 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43771 PyObject *obj;
43772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43773 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43774 return SWIG_Py_Void();
43775 }
43776
43777 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43778 return SWIG_Python_InitShadowInstance(args);
43779 }
43780
43781 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43782 PyObject *resultobj = 0;
43783 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43784 wxString *arg2 = 0 ;
43785 PyObject *arg3 = (PyObject *) NULL ;
43786 int result;
43787 void *argp1 = 0 ;
43788 int res1 = 0 ;
43789 bool temp2 = false ;
43790 PyObject * obj0 = 0 ;
43791 PyObject * obj1 = 0 ;
43792 PyObject * obj2 = 0 ;
43793 char * kwnames[] = {
43794 (char *) "self",(char *) "item",(char *) "clientData", NULL
43795 };
43796
43797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43799 if (!SWIG_IsOK(res1)) {
43800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43801 }
43802 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43803 {
43804 arg2 = wxString_in_helper(obj1);
43805 if (arg2 == NULL) SWIG_fail;
43806 temp2 = true;
43807 }
43808 if (obj2) {
43809 arg3 = obj2;
43810 }
43811 {
43812 PyThreadState* __tstate = wxPyBeginAllowThreads();
43813 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43814 wxPyEndAllowThreads(__tstate);
43815 if (PyErr_Occurred()) SWIG_fail;
43816 }
43817 resultobj = SWIG_From_int(static_cast< int >(result));
43818 {
43819 if (temp2)
43820 delete arg2;
43821 }
43822 return resultobj;
43823 fail:
43824 {
43825 if (temp2)
43826 delete arg2;
43827 }
43828 return NULL;
43829 }
43830
43831
43832 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43833 PyObject *resultobj = 0;
43834 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43835 wxArrayString *arg2 = 0 ;
43836 void *argp1 = 0 ;
43837 int res1 = 0 ;
43838 bool temp2 = false ;
43839 PyObject * obj0 = 0 ;
43840 PyObject * obj1 = 0 ;
43841 char * kwnames[] = {
43842 (char *) "self",(char *) "strings", NULL
43843 };
43844
43845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43847 if (!SWIG_IsOK(res1)) {
43848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43849 }
43850 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43851 {
43852 if (! PySequence_Check(obj1)) {
43853 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43854 SWIG_fail;
43855 }
43856 arg2 = new wxArrayString;
43857 temp2 = true;
43858 int i, len=PySequence_Length(obj1);
43859 for (i=0; i<len; i++) {
43860 PyObject* item = PySequence_GetItem(obj1, i);
43861 wxString* s = wxString_in_helper(item);
43862 if (PyErr_Occurred()) SWIG_fail;
43863 arg2->Add(*s);
43864 delete s;
43865 Py_DECREF(item);
43866 }
43867 }
43868 {
43869 PyThreadState* __tstate = wxPyBeginAllowThreads();
43870 (arg1)->Append((wxArrayString const &)*arg2);
43871 wxPyEndAllowThreads(__tstate);
43872 if (PyErr_Occurred()) SWIG_fail;
43873 }
43874 resultobj = SWIG_Py_Void();
43875 {
43876 if (temp2) delete arg2;
43877 }
43878 return resultobj;
43879 fail:
43880 {
43881 if (temp2) delete arg2;
43882 }
43883 return NULL;
43884 }
43885
43886
43887 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43888 PyObject *resultobj = 0;
43889 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43890 wxString *arg2 = 0 ;
43891 unsigned int arg3 ;
43892 PyObject *arg4 = (PyObject *) NULL ;
43893 int result;
43894 void *argp1 = 0 ;
43895 int res1 = 0 ;
43896 bool temp2 = false ;
43897 unsigned int val3 ;
43898 int ecode3 = 0 ;
43899 PyObject * obj0 = 0 ;
43900 PyObject * obj1 = 0 ;
43901 PyObject * obj2 = 0 ;
43902 PyObject * obj3 = 0 ;
43903 char * kwnames[] = {
43904 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
43905 };
43906
43907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43909 if (!SWIG_IsOK(res1)) {
43910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43911 }
43912 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43913 {
43914 arg2 = wxString_in_helper(obj1);
43915 if (arg2 == NULL) SWIG_fail;
43916 temp2 = true;
43917 }
43918 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
43919 if (!SWIG_IsOK(ecode3)) {
43920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
43921 }
43922 arg3 = static_cast< unsigned int >(val3);
43923 if (obj3) {
43924 arg4 = obj3;
43925 }
43926 {
43927 PyThreadState* __tstate = wxPyBeginAllowThreads();
43928 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
43929 wxPyEndAllowThreads(__tstate);
43930 if (PyErr_Occurred()) SWIG_fail;
43931 }
43932 resultobj = SWIG_From_int(static_cast< int >(result));
43933 {
43934 if (temp2)
43935 delete arg2;
43936 }
43937 return resultobj;
43938 fail:
43939 {
43940 if (temp2)
43941 delete arg2;
43942 }
43943 return NULL;
43944 }
43945
43946
43947 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43948 PyObject *resultobj = 0;
43949 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43950 void *argp1 = 0 ;
43951 int res1 = 0 ;
43952 PyObject *swig_obj[1] ;
43953
43954 if (!args) SWIG_fail;
43955 swig_obj[0] = args;
43956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43957 if (!SWIG_IsOK(res1)) {
43958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43959 }
43960 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43961 {
43962 PyThreadState* __tstate = wxPyBeginAllowThreads();
43963 (arg1)->Clear();
43964 wxPyEndAllowThreads(__tstate);
43965 if (PyErr_Occurred()) SWIG_fail;
43966 }
43967 resultobj = SWIG_Py_Void();
43968 return resultobj;
43969 fail:
43970 return NULL;
43971 }
43972
43973
43974 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43975 PyObject *resultobj = 0;
43976 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43977 unsigned int arg2 ;
43978 void *argp1 = 0 ;
43979 int res1 = 0 ;
43980 unsigned int val2 ;
43981 int ecode2 = 0 ;
43982 PyObject * obj0 = 0 ;
43983 PyObject * obj1 = 0 ;
43984 char * kwnames[] = {
43985 (char *) "self",(char *) "n", NULL
43986 };
43987
43988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43990 if (!SWIG_IsOK(res1)) {
43991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43992 }
43993 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43994 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
43995 if (!SWIG_IsOK(ecode2)) {
43996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
43997 }
43998 arg2 = static_cast< unsigned int >(val2);
43999 {
44000 PyThreadState* __tstate = wxPyBeginAllowThreads();
44001 (arg1)->Delete(arg2);
44002 wxPyEndAllowThreads(__tstate);
44003 if (PyErr_Occurred()) SWIG_fail;
44004 }
44005 resultobj = SWIG_Py_Void();
44006 return resultobj;
44007 fail:
44008 return NULL;
44009 }
44010
44011
44012 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44013 PyObject *resultobj = 0;
44014 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44015 unsigned int arg2 ;
44016 PyObject *result = 0 ;
44017 void *argp1 = 0 ;
44018 int res1 = 0 ;
44019 unsigned int val2 ;
44020 int ecode2 = 0 ;
44021 PyObject * obj0 = 0 ;
44022 PyObject * obj1 = 0 ;
44023 char * kwnames[] = {
44024 (char *) "self",(char *) "n", NULL
44025 };
44026
44027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44029 if (!SWIG_IsOK(res1)) {
44030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44031 }
44032 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44033 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44034 if (!SWIG_IsOK(ecode2)) {
44035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44036 }
44037 arg2 = static_cast< unsigned int >(val2);
44038 {
44039 PyThreadState* __tstate = wxPyBeginAllowThreads();
44040 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44041 wxPyEndAllowThreads(__tstate);
44042 if (PyErr_Occurred()) SWIG_fail;
44043 }
44044 resultobj = result;
44045 return resultobj;
44046 fail:
44047 return NULL;
44048 }
44049
44050
44051 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44052 PyObject *resultobj = 0;
44053 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44054 unsigned int arg2 ;
44055 PyObject *arg3 = (PyObject *) 0 ;
44056 void *argp1 = 0 ;
44057 int res1 = 0 ;
44058 unsigned int val2 ;
44059 int ecode2 = 0 ;
44060 PyObject * obj0 = 0 ;
44061 PyObject * obj1 = 0 ;
44062 PyObject * obj2 = 0 ;
44063 char * kwnames[] = {
44064 (char *) "self",(char *) "n",(char *) "clientData", NULL
44065 };
44066
44067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44069 if (!SWIG_IsOK(res1)) {
44070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44071 }
44072 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44073 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44074 if (!SWIG_IsOK(ecode2)) {
44075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44076 }
44077 arg2 = static_cast< unsigned int >(val2);
44078 arg3 = obj2;
44079 {
44080 PyThreadState* __tstate = wxPyBeginAllowThreads();
44081 wxItemContainer_SetClientData(arg1,arg2,arg3);
44082 wxPyEndAllowThreads(__tstate);
44083 if (PyErr_Occurred()) SWIG_fail;
44084 }
44085 resultobj = SWIG_Py_Void();
44086 return resultobj;
44087 fail:
44088 return NULL;
44089 }
44090
44091
44092 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44093 PyObject *resultobj = 0;
44094 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44095 unsigned int result;
44096 void *argp1 = 0 ;
44097 int res1 = 0 ;
44098 PyObject *swig_obj[1] ;
44099
44100 if (!args) SWIG_fail;
44101 swig_obj[0] = args;
44102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44103 if (!SWIG_IsOK(res1)) {
44104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44105 }
44106 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44107 {
44108 PyThreadState* __tstate = wxPyBeginAllowThreads();
44109 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44110 wxPyEndAllowThreads(__tstate);
44111 if (PyErr_Occurred()) SWIG_fail;
44112 }
44113 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44114 return resultobj;
44115 fail:
44116 return NULL;
44117 }
44118
44119
44120 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44121 PyObject *resultobj = 0;
44122 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44123 bool result;
44124 void *argp1 = 0 ;
44125 int res1 = 0 ;
44126 PyObject *swig_obj[1] ;
44127
44128 if (!args) SWIG_fail;
44129 swig_obj[0] = args;
44130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44131 if (!SWIG_IsOK(res1)) {
44132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44133 }
44134 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44135 {
44136 PyThreadState* __tstate = wxPyBeginAllowThreads();
44137 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44138 wxPyEndAllowThreads(__tstate);
44139 if (PyErr_Occurred()) SWIG_fail;
44140 }
44141 {
44142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44143 }
44144 return resultobj;
44145 fail:
44146 return NULL;
44147 }
44148
44149
44150 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44151 PyObject *resultobj = 0;
44152 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44153 unsigned int arg2 ;
44154 wxString result;
44155 void *argp1 = 0 ;
44156 int res1 = 0 ;
44157 unsigned int val2 ;
44158 int ecode2 = 0 ;
44159 PyObject * obj0 = 0 ;
44160 PyObject * obj1 = 0 ;
44161 char * kwnames[] = {
44162 (char *) "self",(char *) "n", NULL
44163 };
44164
44165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44167 if (!SWIG_IsOK(res1)) {
44168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44169 }
44170 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44171 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44172 if (!SWIG_IsOK(ecode2)) {
44173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44174 }
44175 arg2 = static_cast< unsigned int >(val2);
44176 {
44177 PyThreadState* __tstate = wxPyBeginAllowThreads();
44178 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44179 wxPyEndAllowThreads(__tstate);
44180 if (PyErr_Occurred()) SWIG_fail;
44181 }
44182 {
44183 #if wxUSE_UNICODE
44184 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44185 #else
44186 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44187 #endif
44188 }
44189 return resultobj;
44190 fail:
44191 return NULL;
44192 }
44193
44194
44195 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44196 PyObject *resultobj = 0;
44197 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44198 wxArrayString result;
44199 void *argp1 = 0 ;
44200 int res1 = 0 ;
44201 PyObject *swig_obj[1] ;
44202
44203 if (!args) SWIG_fail;
44204 swig_obj[0] = args;
44205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44206 if (!SWIG_IsOK(res1)) {
44207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44208 }
44209 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44210 {
44211 PyThreadState* __tstate = wxPyBeginAllowThreads();
44212 result = ((wxItemContainer const *)arg1)->GetStrings();
44213 wxPyEndAllowThreads(__tstate);
44214 if (PyErr_Occurred()) SWIG_fail;
44215 }
44216 {
44217 resultobj = wxArrayString2PyList_helper(result);
44218 }
44219 return resultobj;
44220 fail:
44221 return NULL;
44222 }
44223
44224
44225 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44226 PyObject *resultobj = 0;
44227 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44228 unsigned int arg2 ;
44229 wxString *arg3 = 0 ;
44230 void *argp1 = 0 ;
44231 int res1 = 0 ;
44232 unsigned int val2 ;
44233 int ecode2 = 0 ;
44234 bool temp3 = false ;
44235 PyObject * obj0 = 0 ;
44236 PyObject * obj1 = 0 ;
44237 PyObject * obj2 = 0 ;
44238 char * kwnames[] = {
44239 (char *) "self",(char *) "n",(char *) "s", NULL
44240 };
44241
44242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44244 if (!SWIG_IsOK(res1)) {
44245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44246 }
44247 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44248 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44249 if (!SWIG_IsOK(ecode2)) {
44250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44251 }
44252 arg2 = static_cast< unsigned int >(val2);
44253 {
44254 arg3 = wxString_in_helper(obj2);
44255 if (arg3 == NULL) SWIG_fail;
44256 temp3 = true;
44257 }
44258 {
44259 PyThreadState* __tstate = wxPyBeginAllowThreads();
44260 (arg1)->SetString(arg2,(wxString const &)*arg3);
44261 wxPyEndAllowThreads(__tstate);
44262 if (PyErr_Occurred()) SWIG_fail;
44263 }
44264 resultobj = SWIG_Py_Void();
44265 {
44266 if (temp3)
44267 delete arg3;
44268 }
44269 return resultobj;
44270 fail:
44271 {
44272 if (temp3)
44273 delete arg3;
44274 }
44275 return NULL;
44276 }
44277
44278
44279 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44280 PyObject *resultobj = 0;
44281 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44282 wxString *arg2 = 0 ;
44283 int result;
44284 void *argp1 = 0 ;
44285 int res1 = 0 ;
44286 bool temp2 = false ;
44287 PyObject * obj0 = 0 ;
44288 PyObject * obj1 = 0 ;
44289 char * kwnames[] = {
44290 (char *) "self",(char *) "s", NULL
44291 };
44292
44293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44295 if (!SWIG_IsOK(res1)) {
44296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44297 }
44298 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44299 {
44300 arg2 = wxString_in_helper(obj1);
44301 if (arg2 == NULL) SWIG_fail;
44302 temp2 = true;
44303 }
44304 {
44305 PyThreadState* __tstate = wxPyBeginAllowThreads();
44306 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44307 wxPyEndAllowThreads(__tstate);
44308 if (PyErr_Occurred()) SWIG_fail;
44309 }
44310 resultobj = SWIG_From_int(static_cast< int >(result));
44311 {
44312 if (temp2)
44313 delete arg2;
44314 }
44315 return resultobj;
44316 fail:
44317 {
44318 if (temp2)
44319 delete arg2;
44320 }
44321 return NULL;
44322 }
44323
44324
44325 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44326 PyObject *resultobj = 0;
44327 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44328 int arg2 ;
44329 void *argp1 = 0 ;
44330 int res1 = 0 ;
44331 int val2 ;
44332 int ecode2 = 0 ;
44333 PyObject * obj0 = 0 ;
44334 PyObject * obj1 = 0 ;
44335 char * kwnames[] = {
44336 (char *) "self",(char *) "n", NULL
44337 };
44338
44339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44341 if (!SWIG_IsOK(res1)) {
44342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44343 }
44344 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44345 ecode2 = SWIG_AsVal_int(obj1, &val2);
44346 if (!SWIG_IsOK(ecode2)) {
44347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44348 }
44349 arg2 = static_cast< int >(val2);
44350 {
44351 PyThreadState* __tstate = wxPyBeginAllowThreads();
44352 (arg1)->SetSelection(arg2);
44353 wxPyEndAllowThreads(__tstate);
44354 if (PyErr_Occurred()) SWIG_fail;
44355 }
44356 resultobj = SWIG_Py_Void();
44357 return resultobj;
44358 fail:
44359 return NULL;
44360 }
44361
44362
44363 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44364 PyObject *resultobj = 0;
44365 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44366 int result;
44367 void *argp1 = 0 ;
44368 int res1 = 0 ;
44369 PyObject *swig_obj[1] ;
44370
44371 if (!args) SWIG_fail;
44372 swig_obj[0] = args;
44373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44374 if (!SWIG_IsOK(res1)) {
44375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44376 }
44377 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44378 {
44379 PyThreadState* __tstate = wxPyBeginAllowThreads();
44380 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44381 wxPyEndAllowThreads(__tstate);
44382 if (PyErr_Occurred()) SWIG_fail;
44383 }
44384 resultobj = SWIG_From_int(static_cast< int >(result));
44385 return resultobj;
44386 fail:
44387 return NULL;
44388 }
44389
44390
44391 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44392 PyObject *resultobj = 0;
44393 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44394 wxString *arg2 = 0 ;
44395 bool result;
44396 void *argp1 = 0 ;
44397 int res1 = 0 ;
44398 bool temp2 = false ;
44399 PyObject * obj0 = 0 ;
44400 PyObject * obj1 = 0 ;
44401 char * kwnames[] = {
44402 (char *) "self",(char *) "s", NULL
44403 };
44404
44405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44407 if (!SWIG_IsOK(res1)) {
44408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44409 }
44410 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44411 {
44412 arg2 = wxString_in_helper(obj1);
44413 if (arg2 == NULL) SWIG_fail;
44414 temp2 = true;
44415 }
44416 {
44417 PyThreadState* __tstate = wxPyBeginAllowThreads();
44418 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44419 wxPyEndAllowThreads(__tstate);
44420 if (PyErr_Occurred()) SWIG_fail;
44421 }
44422 {
44423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44424 }
44425 {
44426 if (temp2)
44427 delete arg2;
44428 }
44429 return resultobj;
44430 fail:
44431 {
44432 if (temp2)
44433 delete arg2;
44434 }
44435 return NULL;
44436 }
44437
44438
44439 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44440 PyObject *resultobj = 0;
44441 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44442 wxString result;
44443 void *argp1 = 0 ;
44444 int res1 = 0 ;
44445 PyObject *swig_obj[1] ;
44446
44447 if (!args) SWIG_fail;
44448 swig_obj[0] = args;
44449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44450 if (!SWIG_IsOK(res1)) {
44451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44452 }
44453 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44454 {
44455 PyThreadState* __tstate = wxPyBeginAllowThreads();
44456 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44457 wxPyEndAllowThreads(__tstate);
44458 if (PyErr_Occurred()) SWIG_fail;
44459 }
44460 {
44461 #if wxUSE_UNICODE
44462 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44463 #else
44464 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44465 #endif
44466 }
44467 return resultobj;
44468 fail:
44469 return NULL;
44470 }
44471
44472
44473 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44474 PyObject *resultobj = 0;
44475 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44476 int arg2 ;
44477 void *argp1 = 0 ;
44478 int res1 = 0 ;
44479 int val2 ;
44480 int ecode2 = 0 ;
44481 PyObject * obj0 = 0 ;
44482 PyObject * obj1 = 0 ;
44483 char * kwnames[] = {
44484 (char *) "self",(char *) "n", NULL
44485 };
44486
44487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44489 if (!SWIG_IsOK(res1)) {
44490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44491 }
44492 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44493 ecode2 = SWIG_AsVal_int(obj1, &val2);
44494 if (!SWIG_IsOK(ecode2)) {
44495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44496 }
44497 arg2 = static_cast< int >(val2);
44498 {
44499 PyThreadState* __tstate = wxPyBeginAllowThreads();
44500 (arg1)->Select(arg2);
44501 wxPyEndAllowThreads(__tstate);
44502 if (PyErr_Occurred()) SWIG_fail;
44503 }
44504 resultobj = SWIG_Py_Void();
44505 return resultobj;
44506 fail:
44507 return NULL;
44508 }
44509
44510
44511 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44512 PyObject *obj;
44513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44514 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44515 return SWIG_Py_Void();
44516 }
44517
44518 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44519 PyObject *obj;
44520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44521 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44522 return SWIG_Py_Void();
44523 }
44524
44525 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44526 PyObject *resultobj = 0;
44527 wxSizerItem *result = 0 ;
44528
44529 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44530 {
44531 PyThreadState* __tstate = wxPyBeginAllowThreads();
44532 result = (wxSizerItem *)new wxSizerItem();
44533 wxPyEndAllowThreads(__tstate);
44534 if (PyErr_Occurred()) SWIG_fail;
44535 }
44536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44537 return resultobj;
44538 fail:
44539 return NULL;
44540 }
44541
44542
44543 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44544 PyObject *resultobj = 0;
44545 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44546 void *argp1 = 0 ;
44547 int res1 = 0 ;
44548 PyObject *swig_obj[1] ;
44549
44550 if (!args) SWIG_fail;
44551 swig_obj[0] = args;
44552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44553 if (!SWIG_IsOK(res1)) {
44554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44555 }
44556 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44557 {
44558 PyThreadState* __tstate = wxPyBeginAllowThreads();
44559 delete arg1;
44560
44561 wxPyEndAllowThreads(__tstate);
44562 if (PyErr_Occurred()) SWIG_fail;
44563 }
44564 resultobj = SWIG_Py_Void();
44565 return resultobj;
44566 fail:
44567 return NULL;
44568 }
44569
44570
44571 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44572 PyObject *resultobj = 0;
44573 wxWindow *arg1 = (wxWindow *) 0 ;
44574 int arg2 ;
44575 int arg3 ;
44576 int arg4 ;
44577 PyObject *arg5 = (PyObject *) NULL ;
44578 wxSizerItem *result = 0 ;
44579 void *argp1 = 0 ;
44580 int res1 = 0 ;
44581 int val2 ;
44582 int ecode2 = 0 ;
44583 int val3 ;
44584 int ecode3 = 0 ;
44585 int val4 ;
44586 int ecode4 = 0 ;
44587 PyObject * obj0 = 0 ;
44588 PyObject * obj1 = 0 ;
44589 PyObject * obj2 = 0 ;
44590 PyObject * obj3 = 0 ;
44591 PyObject * obj4 = 0 ;
44592 char * kwnames[] = {
44593 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44594 };
44595
44596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44598 if (!SWIG_IsOK(res1)) {
44599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44600 }
44601 arg1 = reinterpret_cast< wxWindow * >(argp1);
44602 ecode2 = SWIG_AsVal_int(obj1, &val2);
44603 if (!SWIG_IsOK(ecode2)) {
44604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44605 }
44606 arg2 = static_cast< int >(val2);
44607 ecode3 = SWIG_AsVal_int(obj2, &val3);
44608 if (!SWIG_IsOK(ecode3)) {
44609 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44610 }
44611 arg3 = static_cast< int >(val3);
44612 ecode4 = SWIG_AsVal_int(obj3, &val4);
44613 if (!SWIG_IsOK(ecode4)) {
44614 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44615 }
44616 arg4 = static_cast< int >(val4);
44617 if (obj4) {
44618 arg5 = obj4;
44619 }
44620 {
44621 PyThreadState* __tstate = wxPyBeginAllowThreads();
44622 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44623 wxPyEndAllowThreads(__tstate);
44624 if (PyErr_Occurred()) SWIG_fail;
44625 }
44626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44627 return resultobj;
44628 fail:
44629 return NULL;
44630 }
44631
44632
44633 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44634 PyObject *resultobj = 0;
44635 int arg1 ;
44636 int arg2 ;
44637 int arg3 ;
44638 int arg4 ;
44639 int arg5 ;
44640 PyObject *arg6 = (PyObject *) NULL ;
44641 wxSizerItem *result = 0 ;
44642 int val1 ;
44643 int ecode1 = 0 ;
44644 int val2 ;
44645 int ecode2 = 0 ;
44646 int val3 ;
44647 int ecode3 = 0 ;
44648 int val4 ;
44649 int ecode4 = 0 ;
44650 int val5 ;
44651 int ecode5 = 0 ;
44652 PyObject * obj0 = 0 ;
44653 PyObject * obj1 = 0 ;
44654 PyObject * obj2 = 0 ;
44655 PyObject * obj3 = 0 ;
44656 PyObject * obj4 = 0 ;
44657 PyObject * obj5 = 0 ;
44658 char * kwnames[] = {
44659 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44660 };
44661
44662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44663 ecode1 = SWIG_AsVal_int(obj0, &val1);
44664 if (!SWIG_IsOK(ecode1)) {
44665 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44666 }
44667 arg1 = static_cast< int >(val1);
44668 ecode2 = SWIG_AsVal_int(obj1, &val2);
44669 if (!SWIG_IsOK(ecode2)) {
44670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44671 }
44672 arg2 = static_cast< int >(val2);
44673 ecode3 = SWIG_AsVal_int(obj2, &val3);
44674 if (!SWIG_IsOK(ecode3)) {
44675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44676 }
44677 arg3 = static_cast< int >(val3);
44678 ecode4 = SWIG_AsVal_int(obj3, &val4);
44679 if (!SWIG_IsOK(ecode4)) {
44680 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44681 }
44682 arg4 = static_cast< int >(val4);
44683 ecode5 = SWIG_AsVal_int(obj4, &val5);
44684 if (!SWIG_IsOK(ecode5)) {
44685 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44686 }
44687 arg5 = static_cast< int >(val5);
44688 if (obj5) {
44689 arg6 = obj5;
44690 }
44691 {
44692 PyThreadState* __tstate = wxPyBeginAllowThreads();
44693 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44694 wxPyEndAllowThreads(__tstate);
44695 if (PyErr_Occurred()) SWIG_fail;
44696 }
44697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44698 return resultobj;
44699 fail:
44700 return NULL;
44701 }
44702
44703
44704 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44705 PyObject *resultobj = 0;
44706 wxSizer *arg1 = (wxSizer *) 0 ;
44707 int arg2 ;
44708 int arg3 ;
44709 int arg4 ;
44710 PyObject *arg5 = (PyObject *) NULL ;
44711 wxSizerItem *result = 0 ;
44712 int res1 = 0 ;
44713 int val2 ;
44714 int ecode2 = 0 ;
44715 int val3 ;
44716 int ecode3 = 0 ;
44717 int val4 ;
44718 int ecode4 = 0 ;
44719 PyObject * obj0 = 0 ;
44720 PyObject * obj1 = 0 ;
44721 PyObject * obj2 = 0 ;
44722 PyObject * obj3 = 0 ;
44723 PyObject * obj4 = 0 ;
44724 char * kwnames[] = {
44725 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44726 };
44727
44728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44729 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44730 if (!SWIG_IsOK(res1)) {
44731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44732 }
44733 ecode2 = SWIG_AsVal_int(obj1, &val2);
44734 if (!SWIG_IsOK(ecode2)) {
44735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44736 }
44737 arg2 = static_cast< int >(val2);
44738 ecode3 = SWIG_AsVal_int(obj2, &val3);
44739 if (!SWIG_IsOK(ecode3)) {
44740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44741 }
44742 arg3 = static_cast< int >(val3);
44743 ecode4 = SWIG_AsVal_int(obj3, &val4);
44744 if (!SWIG_IsOK(ecode4)) {
44745 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44746 }
44747 arg4 = static_cast< int >(val4);
44748 if (obj4) {
44749 arg5 = obj4;
44750 }
44751 {
44752 PyThreadState* __tstate = wxPyBeginAllowThreads();
44753 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44754 wxPyEndAllowThreads(__tstate);
44755 if (PyErr_Occurred()) SWIG_fail;
44756 }
44757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44758 return resultobj;
44759 fail:
44760 return NULL;
44761 }
44762
44763
44764 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44765 PyObject *resultobj = 0;
44766 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44767 void *argp1 = 0 ;
44768 int res1 = 0 ;
44769 PyObject *swig_obj[1] ;
44770
44771 if (!args) SWIG_fail;
44772 swig_obj[0] = args;
44773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44774 if (!SWIG_IsOK(res1)) {
44775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44776 }
44777 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44778 {
44779 PyThreadState* __tstate = wxPyBeginAllowThreads();
44780 (arg1)->DeleteWindows();
44781 wxPyEndAllowThreads(__tstate);
44782 if (PyErr_Occurred()) SWIG_fail;
44783 }
44784 resultobj = SWIG_Py_Void();
44785 return resultobj;
44786 fail:
44787 return NULL;
44788 }
44789
44790
44791 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44792 PyObject *resultobj = 0;
44793 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44794 void *argp1 = 0 ;
44795 int res1 = 0 ;
44796 PyObject *swig_obj[1] ;
44797
44798 if (!args) SWIG_fail;
44799 swig_obj[0] = args;
44800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44801 if (!SWIG_IsOK(res1)) {
44802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44803 }
44804 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44805 {
44806 PyThreadState* __tstate = wxPyBeginAllowThreads();
44807 (arg1)->DetachSizer();
44808 wxPyEndAllowThreads(__tstate);
44809 if (PyErr_Occurred()) SWIG_fail;
44810 }
44811 resultobj = SWIG_Py_Void();
44812 return resultobj;
44813 fail:
44814 return NULL;
44815 }
44816
44817
44818 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44819 PyObject *resultobj = 0;
44820 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44821 wxSize result;
44822 void *argp1 = 0 ;
44823 int res1 = 0 ;
44824 PyObject *swig_obj[1] ;
44825
44826 if (!args) SWIG_fail;
44827 swig_obj[0] = args;
44828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44829 if (!SWIG_IsOK(res1)) {
44830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44831 }
44832 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44833 {
44834 PyThreadState* __tstate = wxPyBeginAllowThreads();
44835 result = (arg1)->GetSize();
44836 wxPyEndAllowThreads(__tstate);
44837 if (PyErr_Occurred()) SWIG_fail;
44838 }
44839 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44840 return resultobj;
44841 fail:
44842 return NULL;
44843 }
44844
44845
44846 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44847 PyObject *resultobj = 0;
44848 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44849 wxSize result;
44850 void *argp1 = 0 ;
44851 int res1 = 0 ;
44852 PyObject *swig_obj[1] ;
44853
44854 if (!args) SWIG_fail;
44855 swig_obj[0] = args;
44856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44857 if (!SWIG_IsOK(res1)) {
44858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44859 }
44860 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44861 {
44862 PyThreadState* __tstate = wxPyBeginAllowThreads();
44863 result = (arg1)->CalcMin();
44864 wxPyEndAllowThreads(__tstate);
44865 if (PyErr_Occurred()) SWIG_fail;
44866 }
44867 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44868 return resultobj;
44869 fail:
44870 return NULL;
44871 }
44872
44873
44874 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44875 PyObject *resultobj = 0;
44876 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44877 wxPoint *arg2 = 0 ;
44878 wxSize *arg3 = 0 ;
44879 void *argp1 = 0 ;
44880 int res1 = 0 ;
44881 wxPoint temp2 ;
44882 wxSize temp3 ;
44883 PyObject * obj0 = 0 ;
44884 PyObject * obj1 = 0 ;
44885 PyObject * obj2 = 0 ;
44886 char * kwnames[] = {
44887 (char *) "self",(char *) "pos",(char *) "size", NULL
44888 };
44889
44890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44892 if (!SWIG_IsOK(res1)) {
44893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44894 }
44895 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44896 {
44897 arg2 = &temp2;
44898 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44899 }
44900 {
44901 arg3 = &temp3;
44902 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
44903 }
44904 {
44905 PyThreadState* __tstate = wxPyBeginAllowThreads();
44906 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
44907 wxPyEndAllowThreads(__tstate);
44908 if (PyErr_Occurred()) SWIG_fail;
44909 }
44910 resultobj = SWIG_Py_Void();
44911 return resultobj;
44912 fail:
44913 return NULL;
44914 }
44915
44916
44917 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44918 PyObject *resultobj = 0;
44919 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44920 wxSize result;
44921 void *argp1 = 0 ;
44922 int res1 = 0 ;
44923 PyObject *swig_obj[1] ;
44924
44925 if (!args) SWIG_fail;
44926 swig_obj[0] = args;
44927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44928 if (!SWIG_IsOK(res1)) {
44929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44930 }
44931 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44932 {
44933 PyThreadState* __tstate = wxPyBeginAllowThreads();
44934 result = (arg1)->GetMinSize();
44935 wxPyEndAllowThreads(__tstate);
44936 if (PyErr_Occurred()) SWIG_fail;
44937 }
44938 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44939 return resultobj;
44940 fail:
44941 return NULL;
44942 }
44943
44944
44945 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44946 PyObject *resultobj = 0;
44947 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44948 wxSize result;
44949 void *argp1 = 0 ;
44950 int res1 = 0 ;
44951 PyObject *swig_obj[1] ;
44952
44953 if (!args) SWIG_fail;
44954 swig_obj[0] = args;
44955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44956 if (!SWIG_IsOK(res1)) {
44957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
44958 }
44959 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44960 {
44961 PyThreadState* __tstate = wxPyBeginAllowThreads();
44962 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
44963 wxPyEndAllowThreads(__tstate);
44964 if (PyErr_Occurred()) SWIG_fail;
44965 }
44966 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44967 return resultobj;
44968 fail:
44969 return NULL;
44970 }
44971
44972
44973 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44974 PyObject *resultobj = 0;
44975 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44976 int arg2 ;
44977 int arg3 ;
44978 void *argp1 = 0 ;
44979 int res1 = 0 ;
44980 int val2 ;
44981 int ecode2 = 0 ;
44982 int val3 ;
44983 int ecode3 = 0 ;
44984 PyObject * obj0 = 0 ;
44985 PyObject * obj1 = 0 ;
44986 PyObject * obj2 = 0 ;
44987 char * kwnames[] = {
44988 (char *) "self",(char *) "x",(char *) "y", NULL
44989 };
44990
44991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44993 if (!SWIG_IsOK(res1)) {
44994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44995 }
44996 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44997 ecode2 = SWIG_AsVal_int(obj1, &val2);
44998 if (!SWIG_IsOK(ecode2)) {
44999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45000 }
45001 arg2 = static_cast< int >(val2);
45002 ecode3 = SWIG_AsVal_int(obj2, &val3);
45003 if (!SWIG_IsOK(ecode3)) {
45004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45005 }
45006 arg3 = static_cast< int >(val3);
45007 {
45008 PyThreadState* __tstate = wxPyBeginAllowThreads();
45009 (arg1)->SetInitSize(arg2,arg3);
45010 wxPyEndAllowThreads(__tstate);
45011 if (PyErr_Occurred()) SWIG_fail;
45012 }
45013 resultobj = SWIG_Py_Void();
45014 return resultobj;
45015 fail:
45016 return NULL;
45017 }
45018
45019
45020 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45021 PyObject *resultobj = 0;
45022 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45023 int arg2 ;
45024 int arg3 ;
45025 void *argp1 = 0 ;
45026 int res1 = 0 ;
45027 int val2 ;
45028 int ecode2 = 0 ;
45029 int val3 ;
45030 int ecode3 = 0 ;
45031 PyObject * obj0 = 0 ;
45032 PyObject * obj1 = 0 ;
45033 PyObject * obj2 = 0 ;
45034 char * kwnames[] = {
45035 (char *) "self",(char *) "width",(char *) "height", NULL
45036 };
45037
45038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45040 if (!SWIG_IsOK(res1)) {
45041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45042 }
45043 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45044 ecode2 = SWIG_AsVal_int(obj1, &val2);
45045 if (!SWIG_IsOK(ecode2)) {
45046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45047 }
45048 arg2 = static_cast< int >(val2);
45049 ecode3 = SWIG_AsVal_int(obj2, &val3);
45050 if (!SWIG_IsOK(ecode3)) {
45051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45052 }
45053 arg3 = static_cast< int >(val3);
45054 {
45055 PyThreadState* __tstate = wxPyBeginAllowThreads();
45056 (arg1)->SetRatio(arg2,arg3);
45057 wxPyEndAllowThreads(__tstate);
45058 if (PyErr_Occurred()) SWIG_fail;
45059 }
45060 resultobj = SWIG_Py_Void();
45061 return resultobj;
45062 fail:
45063 return NULL;
45064 }
45065
45066
45067 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45068 PyObject *resultobj = 0;
45069 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45070 wxSize *arg2 = 0 ;
45071 void *argp1 = 0 ;
45072 int res1 = 0 ;
45073 wxSize temp2 ;
45074 PyObject * obj0 = 0 ;
45075 PyObject * obj1 = 0 ;
45076 char * kwnames[] = {
45077 (char *) "self",(char *) "size", NULL
45078 };
45079
45080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45082 if (!SWIG_IsOK(res1)) {
45083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45084 }
45085 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45086 {
45087 arg2 = &temp2;
45088 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45089 }
45090 {
45091 PyThreadState* __tstate = wxPyBeginAllowThreads();
45092 (arg1)->SetRatio((wxSize const &)*arg2);
45093 wxPyEndAllowThreads(__tstate);
45094 if (PyErr_Occurred()) SWIG_fail;
45095 }
45096 resultobj = SWIG_Py_Void();
45097 return resultobj;
45098 fail:
45099 return NULL;
45100 }
45101
45102
45103 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45104 PyObject *resultobj = 0;
45105 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45106 float arg2 ;
45107 void *argp1 = 0 ;
45108 int res1 = 0 ;
45109 float val2 ;
45110 int ecode2 = 0 ;
45111 PyObject * obj0 = 0 ;
45112 PyObject * obj1 = 0 ;
45113 char * kwnames[] = {
45114 (char *) "self",(char *) "ratio", NULL
45115 };
45116
45117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45119 if (!SWIG_IsOK(res1)) {
45120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45121 }
45122 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45123 ecode2 = SWIG_AsVal_float(obj1, &val2);
45124 if (!SWIG_IsOK(ecode2)) {
45125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45126 }
45127 arg2 = static_cast< float >(val2);
45128 {
45129 PyThreadState* __tstate = wxPyBeginAllowThreads();
45130 (arg1)->SetRatio(arg2);
45131 wxPyEndAllowThreads(__tstate);
45132 if (PyErr_Occurred()) SWIG_fail;
45133 }
45134 resultobj = SWIG_Py_Void();
45135 return resultobj;
45136 fail:
45137 return NULL;
45138 }
45139
45140
45141 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45142 PyObject *resultobj = 0;
45143 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45144 float result;
45145 void *argp1 = 0 ;
45146 int res1 = 0 ;
45147 PyObject *swig_obj[1] ;
45148
45149 if (!args) SWIG_fail;
45150 swig_obj[0] = args;
45151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45152 if (!SWIG_IsOK(res1)) {
45153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45154 }
45155 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45156 {
45157 PyThreadState* __tstate = wxPyBeginAllowThreads();
45158 result = (float)(arg1)->GetRatio();
45159 wxPyEndAllowThreads(__tstate);
45160 if (PyErr_Occurred()) SWIG_fail;
45161 }
45162 resultobj = SWIG_From_float(static_cast< float >(result));
45163 return resultobj;
45164 fail:
45165 return NULL;
45166 }
45167
45168
45169 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45170 PyObject *resultobj = 0;
45171 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45172 wxRect result;
45173 void *argp1 = 0 ;
45174 int res1 = 0 ;
45175 PyObject *swig_obj[1] ;
45176
45177 if (!args) SWIG_fail;
45178 swig_obj[0] = args;
45179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45180 if (!SWIG_IsOK(res1)) {
45181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45182 }
45183 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45184 {
45185 PyThreadState* __tstate = wxPyBeginAllowThreads();
45186 result = (arg1)->GetRect();
45187 wxPyEndAllowThreads(__tstate);
45188 if (PyErr_Occurred()) SWIG_fail;
45189 }
45190 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45191 return resultobj;
45192 fail:
45193 return NULL;
45194 }
45195
45196
45197 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45198 PyObject *resultobj = 0;
45199 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45200 bool result;
45201 void *argp1 = 0 ;
45202 int res1 = 0 ;
45203 PyObject *swig_obj[1] ;
45204
45205 if (!args) SWIG_fail;
45206 swig_obj[0] = args;
45207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45208 if (!SWIG_IsOK(res1)) {
45209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45210 }
45211 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45212 {
45213 PyThreadState* __tstate = wxPyBeginAllowThreads();
45214 result = (bool)(arg1)->IsWindow();
45215 wxPyEndAllowThreads(__tstate);
45216 if (PyErr_Occurred()) SWIG_fail;
45217 }
45218 {
45219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45220 }
45221 return resultobj;
45222 fail:
45223 return NULL;
45224 }
45225
45226
45227 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45228 PyObject *resultobj = 0;
45229 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45230 bool result;
45231 void *argp1 = 0 ;
45232 int res1 = 0 ;
45233 PyObject *swig_obj[1] ;
45234
45235 if (!args) SWIG_fail;
45236 swig_obj[0] = args;
45237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45238 if (!SWIG_IsOK(res1)) {
45239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45240 }
45241 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45242 {
45243 PyThreadState* __tstate = wxPyBeginAllowThreads();
45244 result = (bool)(arg1)->IsSizer();
45245 wxPyEndAllowThreads(__tstate);
45246 if (PyErr_Occurred()) SWIG_fail;
45247 }
45248 {
45249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45250 }
45251 return resultobj;
45252 fail:
45253 return NULL;
45254 }
45255
45256
45257 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45258 PyObject *resultobj = 0;
45259 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45260 bool result;
45261 void *argp1 = 0 ;
45262 int res1 = 0 ;
45263 PyObject *swig_obj[1] ;
45264
45265 if (!args) SWIG_fail;
45266 swig_obj[0] = args;
45267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45268 if (!SWIG_IsOK(res1)) {
45269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45270 }
45271 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45272 {
45273 PyThreadState* __tstate = wxPyBeginAllowThreads();
45274 result = (bool)(arg1)->IsSpacer();
45275 wxPyEndAllowThreads(__tstate);
45276 if (PyErr_Occurred()) SWIG_fail;
45277 }
45278 {
45279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45280 }
45281 return resultobj;
45282 fail:
45283 return NULL;
45284 }
45285
45286
45287 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45288 PyObject *resultobj = 0;
45289 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45290 int arg2 ;
45291 void *argp1 = 0 ;
45292 int res1 = 0 ;
45293 int val2 ;
45294 int ecode2 = 0 ;
45295 PyObject * obj0 = 0 ;
45296 PyObject * obj1 = 0 ;
45297 char * kwnames[] = {
45298 (char *) "self",(char *) "proportion", NULL
45299 };
45300
45301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45303 if (!SWIG_IsOK(res1)) {
45304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45305 }
45306 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45307 ecode2 = SWIG_AsVal_int(obj1, &val2);
45308 if (!SWIG_IsOK(ecode2)) {
45309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45310 }
45311 arg2 = static_cast< int >(val2);
45312 {
45313 PyThreadState* __tstate = wxPyBeginAllowThreads();
45314 (arg1)->SetProportion(arg2);
45315 wxPyEndAllowThreads(__tstate);
45316 if (PyErr_Occurred()) SWIG_fail;
45317 }
45318 resultobj = SWIG_Py_Void();
45319 return resultobj;
45320 fail:
45321 return NULL;
45322 }
45323
45324
45325 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45326 PyObject *resultobj = 0;
45327 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45328 int result;
45329 void *argp1 = 0 ;
45330 int res1 = 0 ;
45331 PyObject *swig_obj[1] ;
45332
45333 if (!args) SWIG_fail;
45334 swig_obj[0] = args;
45335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45336 if (!SWIG_IsOK(res1)) {
45337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45338 }
45339 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45340 {
45341 PyThreadState* __tstate = wxPyBeginAllowThreads();
45342 result = (int)(arg1)->GetProportion();
45343 wxPyEndAllowThreads(__tstate);
45344 if (PyErr_Occurred()) SWIG_fail;
45345 }
45346 resultobj = SWIG_From_int(static_cast< int >(result));
45347 return resultobj;
45348 fail:
45349 return NULL;
45350 }
45351
45352
45353 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45354 PyObject *resultobj = 0;
45355 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45356 int arg2 ;
45357 void *argp1 = 0 ;
45358 int res1 = 0 ;
45359 int val2 ;
45360 int ecode2 = 0 ;
45361 PyObject * obj0 = 0 ;
45362 PyObject * obj1 = 0 ;
45363 char * kwnames[] = {
45364 (char *) "self",(char *) "flag", NULL
45365 };
45366
45367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45369 if (!SWIG_IsOK(res1)) {
45370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45371 }
45372 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45373 ecode2 = SWIG_AsVal_int(obj1, &val2);
45374 if (!SWIG_IsOK(ecode2)) {
45375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45376 }
45377 arg2 = static_cast< int >(val2);
45378 {
45379 PyThreadState* __tstate = wxPyBeginAllowThreads();
45380 (arg1)->SetFlag(arg2);
45381 wxPyEndAllowThreads(__tstate);
45382 if (PyErr_Occurred()) SWIG_fail;
45383 }
45384 resultobj = SWIG_Py_Void();
45385 return resultobj;
45386 fail:
45387 return NULL;
45388 }
45389
45390
45391 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45392 PyObject *resultobj = 0;
45393 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45394 int result;
45395 void *argp1 = 0 ;
45396 int res1 = 0 ;
45397 PyObject *swig_obj[1] ;
45398
45399 if (!args) SWIG_fail;
45400 swig_obj[0] = args;
45401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45402 if (!SWIG_IsOK(res1)) {
45403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45404 }
45405 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45406 {
45407 PyThreadState* __tstate = wxPyBeginAllowThreads();
45408 result = (int)(arg1)->GetFlag();
45409 wxPyEndAllowThreads(__tstate);
45410 if (PyErr_Occurred()) SWIG_fail;
45411 }
45412 resultobj = SWIG_From_int(static_cast< int >(result));
45413 return resultobj;
45414 fail:
45415 return NULL;
45416 }
45417
45418
45419 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45420 PyObject *resultobj = 0;
45421 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45422 int arg2 ;
45423 void *argp1 = 0 ;
45424 int res1 = 0 ;
45425 int val2 ;
45426 int ecode2 = 0 ;
45427 PyObject * obj0 = 0 ;
45428 PyObject * obj1 = 0 ;
45429 char * kwnames[] = {
45430 (char *) "self",(char *) "border", NULL
45431 };
45432
45433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45435 if (!SWIG_IsOK(res1)) {
45436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45437 }
45438 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45439 ecode2 = SWIG_AsVal_int(obj1, &val2);
45440 if (!SWIG_IsOK(ecode2)) {
45441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45442 }
45443 arg2 = static_cast< int >(val2);
45444 {
45445 PyThreadState* __tstate = wxPyBeginAllowThreads();
45446 (arg1)->SetBorder(arg2);
45447 wxPyEndAllowThreads(__tstate);
45448 if (PyErr_Occurred()) SWIG_fail;
45449 }
45450 resultobj = SWIG_Py_Void();
45451 return resultobj;
45452 fail:
45453 return NULL;
45454 }
45455
45456
45457 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45458 PyObject *resultobj = 0;
45459 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45460 int result;
45461 void *argp1 = 0 ;
45462 int res1 = 0 ;
45463 PyObject *swig_obj[1] ;
45464
45465 if (!args) SWIG_fail;
45466 swig_obj[0] = args;
45467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45468 if (!SWIG_IsOK(res1)) {
45469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45470 }
45471 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45472 {
45473 PyThreadState* __tstate = wxPyBeginAllowThreads();
45474 result = (int)(arg1)->GetBorder();
45475 wxPyEndAllowThreads(__tstate);
45476 if (PyErr_Occurred()) SWIG_fail;
45477 }
45478 resultobj = SWIG_From_int(static_cast< int >(result));
45479 return resultobj;
45480 fail:
45481 return NULL;
45482 }
45483
45484
45485 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45486 PyObject *resultobj = 0;
45487 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45488 wxWindow *result = 0 ;
45489 void *argp1 = 0 ;
45490 int res1 = 0 ;
45491 PyObject *swig_obj[1] ;
45492
45493 if (!args) SWIG_fail;
45494 swig_obj[0] = args;
45495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45496 if (!SWIG_IsOK(res1)) {
45497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45498 }
45499 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45500 {
45501 PyThreadState* __tstate = wxPyBeginAllowThreads();
45502 result = (wxWindow *)(arg1)->GetWindow();
45503 wxPyEndAllowThreads(__tstate);
45504 if (PyErr_Occurred()) SWIG_fail;
45505 }
45506 {
45507 resultobj = wxPyMake_wxObject(result, 0);
45508 }
45509 return resultobj;
45510 fail:
45511 return NULL;
45512 }
45513
45514
45515 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45516 PyObject *resultobj = 0;
45517 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45518 wxWindow *arg2 = (wxWindow *) 0 ;
45519 void *argp1 = 0 ;
45520 int res1 = 0 ;
45521 void *argp2 = 0 ;
45522 int res2 = 0 ;
45523 PyObject * obj0 = 0 ;
45524 PyObject * obj1 = 0 ;
45525 char * kwnames[] = {
45526 (char *) "self",(char *) "window", NULL
45527 };
45528
45529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45531 if (!SWIG_IsOK(res1)) {
45532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45533 }
45534 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45535 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45536 if (!SWIG_IsOK(res2)) {
45537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45538 }
45539 arg2 = reinterpret_cast< wxWindow * >(argp2);
45540 {
45541 PyThreadState* __tstate = wxPyBeginAllowThreads();
45542 (arg1)->SetWindow(arg2);
45543 wxPyEndAllowThreads(__tstate);
45544 if (PyErr_Occurred()) SWIG_fail;
45545 }
45546 resultobj = SWIG_Py_Void();
45547 return resultobj;
45548 fail:
45549 return NULL;
45550 }
45551
45552
45553 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45554 PyObject *resultobj = 0;
45555 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45556 wxSizer *result = 0 ;
45557 void *argp1 = 0 ;
45558 int res1 = 0 ;
45559 PyObject *swig_obj[1] ;
45560
45561 if (!args) SWIG_fail;
45562 swig_obj[0] = args;
45563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45564 if (!SWIG_IsOK(res1)) {
45565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45566 }
45567 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45568 {
45569 PyThreadState* __tstate = wxPyBeginAllowThreads();
45570 result = (wxSizer *)(arg1)->GetSizer();
45571 wxPyEndAllowThreads(__tstate);
45572 if (PyErr_Occurred()) SWIG_fail;
45573 }
45574 {
45575 resultobj = wxPyMake_wxObject(result, (bool)0);
45576 }
45577 return resultobj;
45578 fail:
45579 return NULL;
45580 }
45581
45582
45583 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45584 PyObject *resultobj = 0;
45585 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45586 wxSizer *arg2 = (wxSizer *) 0 ;
45587 void *argp1 = 0 ;
45588 int res1 = 0 ;
45589 int res2 = 0 ;
45590 PyObject * obj0 = 0 ;
45591 PyObject * obj1 = 0 ;
45592 char * kwnames[] = {
45593 (char *) "self",(char *) "sizer", NULL
45594 };
45595
45596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45598 if (!SWIG_IsOK(res1)) {
45599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45600 }
45601 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45602 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45603 if (!SWIG_IsOK(res2)) {
45604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45605 }
45606 {
45607 PyThreadState* __tstate = wxPyBeginAllowThreads();
45608 (arg1)->SetSizer(arg2);
45609 wxPyEndAllowThreads(__tstate);
45610 if (PyErr_Occurred()) SWIG_fail;
45611 }
45612 resultobj = SWIG_Py_Void();
45613 return resultobj;
45614 fail:
45615 return NULL;
45616 }
45617
45618
45619 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45620 PyObject *resultobj = 0;
45621 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45622 wxSize *result = 0 ;
45623 void *argp1 = 0 ;
45624 int res1 = 0 ;
45625 PyObject *swig_obj[1] ;
45626
45627 if (!args) SWIG_fail;
45628 swig_obj[0] = args;
45629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45630 if (!SWIG_IsOK(res1)) {
45631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45632 }
45633 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45634 {
45635 PyThreadState* __tstate = wxPyBeginAllowThreads();
45636 {
45637 wxSize const &_result_ref = (arg1)->GetSpacer();
45638 result = (wxSize *) &_result_ref;
45639 }
45640 wxPyEndAllowThreads(__tstate);
45641 if (PyErr_Occurred()) SWIG_fail;
45642 }
45643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45644 return resultobj;
45645 fail:
45646 return NULL;
45647 }
45648
45649
45650 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45651 PyObject *resultobj = 0;
45652 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45653 wxSize *arg2 = 0 ;
45654 void *argp1 = 0 ;
45655 int res1 = 0 ;
45656 wxSize temp2 ;
45657 PyObject * obj0 = 0 ;
45658 PyObject * obj1 = 0 ;
45659 char * kwnames[] = {
45660 (char *) "self",(char *) "size", NULL
45661 };
45662
45663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45665 if (!SWIG_IsOK(res1)) {
45666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45667 }
45668 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45669 {
45670 arg2 = &temp2;
45671 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45672 }
45673 {
45674 PyThreadState* __tstate = wxPyBeginAllowThreads();
45675 (arg1)->SetSpacer((wxSize const &)*arg2);
45676 wxPyEndAllowThreads(__tstate);
45677 if (PyErr_Occurred()) SWIG_fail;
45678 }
45679 resultobj = SWIG_Py_Void();
45680 return resultobj;
45681 fail:
45682 return NULL;
45683 }
45684
45685
45686 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45687 PyObject *resultobj = 0;
45688 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45689 bool arg2 ;
45690 void *argp1 = 0 ;
45691 int res1 = 0 ;
45692 bool val2 ;
45693 int ecode2 = 0 ;
45694 PyObject * obj0 = 0 ;
45695 PyObject * obj1 = 0 ;
45696 char * kwnames[] = {
45697 (char *) "self",(char *) "show", NULL
45698 };
45699
45700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45702 if (!SWIG_IsOK(res1)) {
45703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45704 }
45705 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45706 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45707 if (!SWIG_IsOK(ecode2)) {
45708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45709 }
45710 arg2 = static_cast< bool >(val2);
45711 {
45712 PyThreadState* __tstate = wxPyBeginAllowThreads();
45713 (arg1)->Show(arg2);
45714 wxPyEndAllowThreads(__tstate);
45715 if (PyErr_Occurred()) SWIG_fail;
45716 }
45717 resultobj = SWIG_Py_Void();
45718 return resultobj;
45719 fail:
45720 return NULL;
45721 }
45722
45723
45724 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45725 PyObject *resultobj = 0;
45726 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45727 bool result;
45728 void *argp1 = 0 ;
45729 int res1 = 0 ;
45730 PyObject *swig_obj[1] ;
45731
45732 if (!args) SWIG_fail;
45733 swig_obj[0] = args;
45734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45735 if (!SWIG_IsOK(res1)) {
45736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45737 }
45738 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45739 {
45740 PyThreadState* __tstate = wxPyBeginAllowThreads();
45741 result = (bool)(arg1)->IsShown();
45742 wxPyEndAllowThreads(__tstate);
45743 if (PyErr_Occurred()) SWIG_fail;
45744 }
45745 {
45746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45747 }
45748 return resultobj;
45749 fail:
45750 return NULL;
45751 }
45752
45753
45754 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45755 PyObject *resultobj = 0;
45756 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45757 wxPoint result;
45758 void *argp1 = 0 ;
45759 int res1 = 0 ;
45760 PyObject *swig_obj[1] ;
45761
45762 if (!args) SWIG_fail;
45763 swig_obj[0] = args;
45764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45765 if (!SWIG_IsOK(res1)) {
45766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45767 }
45768 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45769 {
45770 PyThreadState* __tstate = wxPyBeginAllowThreads();
45771 result = (arg1)->GetPosition();
45772 wxPyEndAllowThreads(__tstate);
45773 if (PyErr_Occurred()) SWIG_fail;
45774 }
45775 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45776 return resultobj;
45777 fail:
45778 return NULL;
45779 }
45780
45781
45782 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45783 PyObject *resultobj = 0;
45784 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45785 PyObject *result = 0 ;
45786 void *argp1 = 0 ;
45787 int res1 = 0 ;
45788 PyObject *swig_obj[1] ;
45789
45790 if (!args) SWIG_fail;
45791 swig_obj[0] = args;
45792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45793 if (!SWIG_IsOK(res1)) {
45794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45795 }
45796 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45797 {
45798 PyThreadState* __tstate = wxPyBeginAllowThreads();
45799 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45800 wxPyEndAllowThreads(__tstate);
45801 if (PyErr_Occurred()) SWIG_fail;
45802 }
45803 resultobj = result;
45804 return resultobj;
45805 fail:
45806 return NULL;
45807 }
45808
45809
45810 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45811 PyObject *resultobj = 0;
45812 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45813 PyObject *arg2 = (PyObject *) 0 ;
45814 void *argp1 = 0 ;
45815 int res1 = 0 ;
45816 PyObject * obj0 = 0 ;
45817 PyObject * obj1 = 0 ;
45818 char * kwnames[] = {
45819 (char *) "self",(char *) "userData", NULL
45820 };
45821
45822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45824 if (!SWIG_IsOK(res1)) {
45825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45826 }
45827 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45828 arg2 = obj1;
45829 {
45830 PyThreadState* __tstate = wxPyBeginAllowThreads();
45831 wxSizerItem_SetUserData(arg1,arg2);
45832 wxPyEndAllowThreads(__tstate);
45833 if (PyErr_Occurred()) SWIG_fail;
45834 }
45835 resultobj = SWIG_Py_Void();
45836 return resultobj;
45837 fail:
45838 return NULL;
45839 }
45840
45841
45842 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45843 PyObject *obj;
45844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45845 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45846 return SWIG_Py_Void();
45847 }
45848
45849 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45850 return SWIG_Python_InitShadowInstance(args);
45851 }
45852
45853 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45854 PyObject *resultobj = 0;
45855 wxSizer *arg1 = (wxSizer *) 0 ;
45856 void *argp1 = 0 ;
45857 int res1 = 0 ;
45858 PyObject *swig_obj[1] ;
45859
45860 if (!args) SWIG_fail;
45861 swig_obj[0] = args;
45862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45863 if (!SWIG_IsOK(res1)) {
45864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45865 }
45866 arg1 = reinterpret_cast< wxSizer * >(argp1);
45867 {
45868 PyThreadState* __tstate = wxPyBeginAllowThreads();
45869 delete arg1;
45870
45871 wxPyEndAllowThreads(__tstate);
45872 if (PyErr_Occurred()) SWIG_fail;
45873 }
45874 resultobj = SWIG_Py_Void();
45875 return resultobj;
45876 fail:
45877 return NULL;
45878 }
45879
45880
45881 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45882 PyObject *resultobj = 0;
45883 wxSizer *arg1 = (wxSizer *) 0 ;
45884 PyObject *arg2 = (PyObject *) 0 ;
45885 void *argp1 = 0 ;
45886 int res1 = 0 ;
45887 PyObject * obj0 = 0 ;
45888 PyObject * obj1 = 0 ;
45889 char * kwnames[] = {
45890 (char *) "self",(char *) "_self", NULL
45891 };
45892
45893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
45894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45895 if (!SWIG_IsOK(res1)) {
45896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
45897 }
45898 arg1 = reinterpret_cast< wxSizer * >(argp1);
45899 arg2 = obj1;
45900 {
45901 PyThreadState* __tstate = wxPyBeginAllowThreads();
45902 wxSizer__setOORInfo(arg1,arg2);
45903 wxPyEndAllowThreads(__tstate);
45904 if (PyErr_Occurred()) SWIG_fail;
45905 }
45906 resultobj = SWIG_Py_Void();
45907 return resultobj;
45908 fail:
45909 return NULL;
45910 }
45911
45912
45913 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45914 PyObject *resultobj = 0;
45915 wxSizer *arg1 = (wxSizer *) 0 ;
45916 PyObject *arg2 = (PyObject *) 0 ;
45917 int arg3 = (int) 0 ;
45918 int arg4 = (int) 0 ;
45919 int arg5 = (int) 0 ;
45920 PyObject *arg6 = (PyObject *) NULL ;
45921 wxSizerItem *result = 0 ;
45922 void *argp1 = 0 ;
45923 int res1 = 0 ;
45924 int val3 ;
45925 int ecode3 = 0 ;
45926 int val4 ;
45927 int ecode4 = 0 ;
45928 int val5 ;
45929 int ecode5 = 0 ;
45930 PyObject * obj0 = 0 ;
45931 PyObject * obj1 = 0 ;
45932 PyObject * obj2 = 0 ;
45933 PyObject * obj3 = 0 ;
45934 PyObject * obj4 = 0 ;
45935 PyObject * obj5 = 0 ;
45936 char * kwnames[] = {
45937 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45938 };
45939
45940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45942 if (!SWIG_IsOK(res1)) {
45943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
45944 }
45945 arg1 = reinterpret_cast< wxSizer * >(argp1);
45946 arg2 = obj1;
45947 if (obj2) {
45948 ecode3 = SWIG_AsVal_int(obj2, &val3);
45949 if (!SWIG_IsOK(ecode3)) {
45950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
45951 }
45952 arg3 = static_cast< int >(val3);
45953 }
45954 if (obj3) {
45955 ecode4 = SWIG_AsVal_int(obj3, &val4);
45956 if (!SWIG_IsOK(ecode4)) {
45957 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
45958 }
45959 arg4 = static_cast< int >(val4);
45960 }
45961 if (obj4) {
45962 ecode5 = SWIG_AsVal_int(obj4, &val5);
45963 if (!SWIG_IsOK(ecode5)) {
45964 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
45965 }
45966 arg5 = static_cast< int >(val5);
45967 }
45968 if (obj5) {
45969 arg6 = obj5;
45970 }
45971 {
45972 PyThreadState* __tstate = wxPyBeginAllowThreads();
45973 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
45974 wxPyEndAllowThreads(__tstate);
45975 if (PyErr_Occurred()) SWIG_fail;
45976 }
45977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
45978 return resultobj;
45979 fail:
45980 return NULL;
45981 }
45982
45983
45984 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45985 PyObject *resultobj = 0;
45986 wxSizer *arg1 = (wxSizer *) 0 ;
45987 int arg2 ;
45988 PyObject *arg3 = (PyObject *) 0 ;
45989 int arg4 = (int) 0 ;
45990 int arg5 = (int) 0 ;
45991 int arg6 = (int) 0 ;
45992 PyObject *arg7 = (PyObject *) NULL ;
45993 wxSizerItem *result = 0 ;
45994 void *argp1 = 0 ;
45995 int res1 = 0 ;
45996 int val2 ;
45997 int ecode2 = 0 ;
45998 int val4 ;
45999 int ecode4 = 0 ;
46000 int val5 ;
46001 int ecode5 = 0 ;
46002 int val6 ;
46003 int ecode6 = 0 ;
46004 PyObject * obj0 = 0 ;
46005 PyObject * obj1 = 0 ;
46006 PyObject * obj2 = 0 ;
46007 PyObject * obj3 = 0 ;
46008 PyObject * obj4 = 0 ;
46009 PyObject * obj5 = 0 ;
46010 PyObject * obj6 = 0 ;
46011 char * kwnames[] = {
46012 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46013 };
46014
46015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46017 if (!SWIG_IsOK(res1)) {
46018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46019 }
46020 arg1 = reinterpret_cast< wxSizer * >(argp1);
46021 ecode2 = SWIG_AsVal_int(obj1, &val2);
46022 if (!SWIG_IsOK(ecode2)) {
46023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46024 }
46025 arg2 = static_cast< int >(val2);
46026 arg3 = obj2;
46027 if (obj3) {
46028 ecode4 = SWIG_AsVal_int(obj3, &val4);
46029 if (!SWIG_IsOK(ecode4)) {
46030 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46031 }
46032 arg4 = static_cast< int >(val4);
46033 }
46034 if (obj4) {
46035 ecode5 = SWIG_AsVal_int(obj4, &val5);
46036 if (!SWIG_IsOK(ecode5)) {
46037 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46038 }
46039 arg5 = static_cast< int >(val5);
46040 }
46041 if (obj5) {
46042 ecode6 = SWIG_AsVal_int(obj5, &val6);
46043 if (!SWIG_IsOK(ecode6)) {
46044 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46045 }
46046 arg6 = static_cast< int >(val6);
46047 }
46048 if (obj6) {
46049 arg7 = obj6;
46050 }
46051 {
46052 PyThreadState* __tstate = wxPyBeginAllowThreads();
46053 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46054 wxPyEndAllowThreads(__tstate);
46055 if (PyErr_Occurred()) SWIG_fail;
46056 }
46057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46058 return resultobj;
46059 fail:
46060 return NULL;
46061 }
46062
46063
46064 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46065 PyObject *resultobj = 0;
46066 wxSizer *arg1 = (wxSizer *) 0 ;
46067 PyObject *arg2 = (PyObject *) 0 ;
46068 int arg3 = (int) 0 ;
46069 int arg4 = (int) 0 ;
46070 int arg5 = (int) 0 ;
46071 PyObject *arg6 = (PyObject *) NULL ;
46072 wxSizerItem *result = 0 ;
46073 void *argp1 = 0 ;
46074 int res1 = 0 ;
46075 int val3 ;
46076 int ecode3 = 0 ;
46077 int val4 ;
46078 int ecode4 = 0 ;
46079 int val5 ;
46080 int ecode5 = 0 ;
46081 PyObject * obj0 = 0 ;
46082 PyObject * obj1 = 0 ;
46083 PyObject * obj2 = 0 ;
46084 PyObject * obj3 = 0 ;
46085 PyObject * obj4 = 0 ;
46086 PyObject * obj5 = 0 ;
46087 char * kwnames[] = {
46088 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46089 };
46090
46091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46093 if (!SWIG_IsOK(res1)) {
46094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46095 }
46096 arg1 = reinterpret_cast< wxSizer * >(argp1);
46097 arg2 = obj1;
46098 if (obj2) {
46099 ecode3 = SWIG_AsVal_int(obj2, &val3);
46100 if (!SWIG_IsOK(ecode3)) {
46101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46102 }
46103 arg3 = static_cast< int >(val3);
46104 }
46105 if (obj3) {
46106 ecode4 = SWIG_AsVal_int(obj3, &val4);
46107 if (!SWIG_IsOK(ecode4)) {
46108 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46109 }
46110 arg4 = static_cast< int >(val4);
46111 }
46112 if (obj4) {
46113 ecode5 = SWIG_AsVal_int(obj4, &val5);
46114 if (!SWIG_IsOK(ecode5)) {
46115 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46116 }
46117 arg5 = static_cast< int >(val5);
46118 }
46119 if (obj5) {
46120 arg6 = obj5;
46121 }
46122 {
46123 PyThreadState* __tstate = wxPyBeginAllowThreads();
46124 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46125 wxPyEndAllowThreads(__tstate);
46126 if (PyErr_Occurred()) SWIG_fail;
46127 }
46128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46129 return resultobj;
46130 fail:
46131 return NULL;
46132 }
46133
46134
46135 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46136 PyObject *resultobj = 0;
46137 wxSizer *arg1 = (wxSizer *) 0 ;
46138 PyObject *arg2 = (PyObject *) 0 ;
46139 bool result;
46140 void *argp1 = 0 ;
46141 int res1 = 0 ;
46142 PyObject * obj0 = 0 ;
46143 PyObject * obj1 = 0 ;
46144 char * kwnames[] = {
46145 (char *) "self",(char *) "item", NULL
46146 };
46147
46148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46150 if (!SWIG_IsOK(res1)) {
46151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46152 }
46153 arg1 = reinterpret_cast< wxSizer * >(argp1);
46154 arg2 = obj1;
46155 {
46156 PyThreadState* __tstate = wxPyBeginAllowThreads();
46157 result = (bool)wxSizer_Remove(arg1,arg2);
46158 wxPyEndAllowThreads(__tstate);
46159 if (PyErr_Occurred()) SWIG_fail;
46160 }
46161 {
46162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46163 }
46164 return resultobj;
46165 fail:
46166 return NULL;
46167 }
46168
46169
46170 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46171 PyObject *resultobj = 0;
46172 wxSizer *arg1 = (wxSizer *) 0 ;
46173 PyObject *arg2 = (PyObject *) 0 ;
46174 bool result;
46175 void *argp1 = 0 ;
46176 int res1 = 0 ;
46177 PyObject * obj0 = 0 ;
46178 PyObject * obj1 = 0 ;
46179 char * kwnames[] = {
46180 (char *) "self",(char *) "item", NULL
46181 };
46182
46183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46185 if (!SWIG_IsOK(res1)) {
46186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46187 }
46188 arg1 = reinterpret_cast< wxSizer * >(argp1);
46189 arg2 = obj1;
46190 {
46191 PyThreadState* __tstate = wxPyBeginAllowThreads();
46192 result = (bool)wxSizer_Detach(arg1,arg2);
46193 wxPyEndAllowThreads(__tstate);
46194 if (PyErr_Occurred()) SWIG_fail;
46195 }
46196 {
46197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46198 }
46199 return resultobj;
46200 fail:
46201 return NULL;
46202 }
46203
46204
46205 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46206 PyObject *resultobj = 0;
46207 wxSizer *arg1 = (wxSizer *) 0 ;
46208 PyObject *arg2 = (PyObject *) 0 ;
46209 wxSizerItem *result = 0 ;
46210 void *argp1 = 0 ;
46211 int res1 = 0 ;
46212 PyObject * obj0 = 0 ;
46213 PyObject * obj1 = 0 ;
46214 char * kwnames[] = {
46215 (char *) "self",(char *) "item", NULL
46216 };
46217
46218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46220 if (!SWIG_IsOK(res1)) {
46221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46222 }
46223 arg1 = reinterpret_cast< wxSizer * >(argp1);
46224 arg2 = obj1;
46225 {
46226 PyThreadState* __tstate = wxPyBeginAllowThreads();
46227 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46228 wxPyEndAllowThreads(__tstate);
46229 if (PyErr_Occurred()) SWIG_fail;
46230 }
46231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46232 return resultobj;
46233 fail:
46234 return NULL;
46235 }
46236
46237
46238 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46239 PyObject *resultobj = 0;
46240 wxSizer *arg1 = (wxSizer *) 0 ;
46241 PyObject *arg2 = (PyObject *) 0 ;
46242 wxSize *arg3 = 0 ;
46243 void *argp1 = 0 ;
46244 int res1 = 0 ;
46245 wxSize temp3 ;
46246 PyObject * obj0 = 0 ;
46247 PyObject * obj1 = 0 ;
46248 PyObject * obj2 = 0 ;
46249 char * kwnames[] = {
46250 (char *) "self",(char *) "item",(char *) "size", NULL
46251 };
46252
46253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46255 if (!SWIG_IsOK(res1)) {
46256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46257 }
46258 arg1 = reinterpret_cast< wxSizer * >(argp1);
46259 arg2 = obj1;
46260 {
46261 arg3 = &temp3;
46262 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46263 }
46264 {
46265 PyThreadState* __tstate = wxPyBeginAllowThreads();
46266 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46267 wxPyEndAllowThreads(__tstate);
46268 if (PyErr_Occurred()) SWIG_fail;
46269 }
46270 resultobj = SWIG_Py_Void();
46271 return resultobj;
46272 fail:
46273 return NULL;
46274 }
46275
46276
46277 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46278 PyObject *resultobj = 0;
46279 wxSizer *arg1 = (wxSizer *) 0 ;
46280 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46281 wxSizerItem *result = 0 ;
46282 void *argp1 = 0 ;
46283 int res1 = 0 ;
46284 int res2 = 0 ;
46285 PyObject * obj0 = 0 ;
46286 PyObject * obj1 = 0 ;
46287 char * kwnames[] = {
46288 (char *) "self",(char *) "item", NULL
46289 };
46290
46291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46293 if (!SWIG_IsOK(res1)) {
46294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46295 }
46296 arg1 = reinterpret_cast< wxSizer * >(argp1);
46297 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46298 if (!SWIG_IsOK(res2)) {
46299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46300 }
46301 {
46302 PyThreadState* __tstate = wxPyBeginAllowThreads();
46303 result = (wxSizerItem *)(arg1)->Add(arg2);
46304 wxPyEndAllowThreads(__tstate);
46305 if (PyErr_Occurred()) SWIG_fail;
46306 }
46307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46308 return resultobj;
46309 fail:
46310 return NULL;
46311 }
46312
46313
46314 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46315 PyObject *resultobj = 0;
46316 wxSizer *arg1 = (wxSizer *) 0 ;
46317 size_t arg2 ;
46318 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46319 wxSizerItem *result = 0 ;
46320 void *argp1 = 0 ;
46321 int res1 = 0 ;
46322 size_t val2 ;
46323 int ecode2 = 0 ;
46324 int res3 = 0 ;
46325 PyObject * obj0 = 0 ;
46326 PyObject * obj1 = 0 ;
46327 PyObject * obj2 = 0 ;
46328 char * kwnames[] = {
46329 (char *) "self",(char *) "index",(char *) "item", NULL
46330 };
46331
46332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46334 if (!SWIG_IsOK(res1)) {
46335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46336 }
46337 arg1 = reinterpret_cast< wxSizer * >(argp1);
46338 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46339 if (!SWIG_IsOK(ecode2)) {
46340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46341 }
46342 arg2 = static_cast< size_t >(val2);
46343 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46344 if (!SWIG_IsOK(res3)) {
46345 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46346 }
46347 {
46348 PyThreadState* __tstate = wxPyBeginAllowThreads();
46349 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46350 wxPyEndAllowThreads(__tstate);
46351 if (PyErr_Occurred()) SWIG_fail;
46352 }
46353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46354 return resultobj;
46355 fail:
46356 return NULL;
46357 }
46358
46359
46360 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46361 PyObject *resultobj = 0;
46362 wxSizer *arg1 = (wxSizer *) 0 ;
46363 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46364 wxSizerItem *result = 0 ;
46365 void *argp1 = 0 ;
46366 int res1 = 0 ;
46367 int res2 = 0 ;
46368 PyObject * obj0 = 0 ;
46369 PyObject * obj1 = 0 ;
46370 char * kwnames[] = {
46371 (char *) "self",(char *) "item", NULL
46372 };
46373
46374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46376 if (!SWIG_IsOK(res1)) {
46377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46378 }
46379 arg1 = reinterpret_cast< wxSizer * >(argp1);
46380 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46381 if (!SWIG_IsOK(res2)) {
46382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46383 }
46384 {
46385 PyThreadState* __tstate = wxPyBeginAllowThreads();
46386 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46387 wxPyEndAllowThreads(__tstate);
46388 if (PyErr_Occurred()) SWIG_fail;
46389 }
46390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46391 return resultobj;
46392 fail:
46393 return NULL;
46394 }
46395
46396
46397 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46398 PyObject *resultobj = 0;
46399 wxSizer *arg1 = (wxSizer *) 0 ;
46400 int arg2 ;
46401 int arg3 ;
46402 int arg4 ;
46403 int arg5 ;
46404 void *argp1 = 0 ;
46405 int res1 = 0 ;
46406 int val2 ;
46407 int ecode2 = 0 ;
46408 int val3 ;
46409 int ecode3 = 0 ;
46410 int val4 ;
46411 int ecode4 = 0 ;
46412 int val5 ;
46413 int ecode5 = 0 ;
46414 PyObject * obj0 = 0 ;
46415 PyObject * obj1 = 0 ;
46416 PyObject * obj2 = 0 ;
46417 PyObject * obj3 = 0 ;
46418 PyObject * obj4 = 0 ;
46419 char * kwnames[] = {
46420 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46421 };
46422
46423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46425 if (!SWIG_IsOK(res1)) {
46426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46427 }
46428 arg1 = reinterpret_cast< wxSizer * >(argp1);
46429 ecode2 = SWIG_AsVal_int(obj1, &val2);
46430 if (!SWIG_IsOK(ecode2)) {
46431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46432 }
46433 arg2 = static_cast< int >(val2);
46434 ecode3 = SWIG_AsVal_int(obj2, &val3);
46435 if (!SWIG_IsOK(ecode3)) {
46436 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46437 }
46438 arg3 = static_cast< int >(val3);
46439 ecode4 = SWIG_AsVal_int(obj3, &val4);
46440 if (!SWIG_IsOK(ecode4)) {
46441 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46442 }
46443 arg4 = static_cast< int >(val4);
46444 ecode5 = SWIG_AsVal_int(obj4, &val5);
46445 if (!SWIG_IsOK(ecode5)) {
46446 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46447 }
46448 arg5 = static_cast< int >(val5);
46449 {
46450 PyThreadState* __tstate = wxPyBeginAllowThreads();
46451 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46452 wxPyEndAllowThreads(__tstate);
46453 if (PyErr_Occurred()) SWIG_fail;
46454 }
46455 resultobj = SWIG_Py_Void();
46456 return resultobj;
46457 fail:
46458 return NULL;
46459 }
46460
46461
46462 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46463 PyObject *resultobj = 0;
46464 wxSizer *arg1 = (wxSizer *) 0 ;
46465 wxSize *arg2 = 0 ;
46466 void *argp1 = 0 ;
46467 int res1 = 0 ;
46468 wxSize temp2 ;
46469 PyObject * obj0 = 0 ;
46470 PyObject * obj1 = 0 ;
46471 char * kwnames[] = {
46472 (char *) "self",(char *) "size", NULL
46473 };
46474
46475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46477 if (!SWIG_IsOK(res1)) {
46478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46479 }
46480 arg1 = reinterpret_cast< wxSizer * >(argp1);
46481 {
46482 arg2 = &temp2;
46483 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46484 }
46485 {
46486 PyThreadState* __tstate = wxPyBeginAllowThreads();
46487 (arg1)->SetMinSize((wxSize const &)*arg2);
46488 wxPyEndAllowThreads(__tstate);
46489 if (PyErr_Occurred()) SWIG_fail;
46490 }
46491 resultobj = SWIG_Py_Void();
46492 return resultobj;
46493 fail:
46494 return NULL;
46495 }
46496
46497
46498 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46499 PyObject *resultobj = 0;
46500 wxSizer *arg1 = (wxSizer *) 0 ;
46501 wxSize result;
46502 void *argp1 = 0 ;
46503 int res1 = 0 ;
46504 PyObject *swig_obj[1] ;
46505
46506 if (!args) SWIG_fail;
46507 swig_obj[0] = args;
46508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46509 if (!SWIG_IsOK(res1)) {
46510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46511 }
46512 arg1 = reinterpret_cast< wxSizer * >(argp1);
46513 {
46514 PyThreadState* __tstate = wxPyBeginAllowThreads();
46515 result = (arg1)->GetSize();
46516 wxPyEndAllowThreads(__tstate);
46517 if (PyErr_Occurred()) SWIG_fail;
46518 }
46519 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46520 return resultobj;
46521 fail:
46522 return NULL;
46523 }
46524
46525
46526 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46527 PyObject *resultobj = 0;
46528 wxSizer *arg1 = (wxSizer *) 0 ;
46529 wxPoint result;
46530 void *argp1 = 0 ;
46531 int res1 = 0 ;
46532 PyObject *swig_obj[1] ;
46533
46534 if (!args) SWIG_fail;
46535 swig_obj[0] = args;
46536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46537 if (!SWIG_IsOK(res1)) {
46538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46539 }
46540 arg1 = reinterpret_cast< wxSizer * >(argp1);
46541 {
46542 PyThreadState* __tstate = wxPyBeginAllowThreads();
46543 result = (arg1)->GetPosition();
46544 wxPyEndAllowThreads(__tstate);
46545 if (PyErr_Occurred()) SWIG_fail;
46546 }
46547 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46548 return resultobj;
46549 fail:
46550 return NULL;
46551 }
46552
46553
46554 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46555 PyObject *resultobj = 0;
46556 wxSizer *arg1 = (wxSizer *) 0 ;
46557 wxSize result;
46558 void *argp1 = 0 ;
46559 int res1 = 0 ;
46560 PyObject *swig_obj[1] ;
46561
46562 if (!args) SWIG_fail;
46563 swig_obj[0] = args;
46564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46565 if (!SWIG_IsOK(res1)) {
46566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46567 }
46568 arg1 = reinterpret_cast< wxSizer * >(argp1);
46569 {
46570 PyThreadState* __tstate = wxPyBeginAllowThreads();
46571 result = (arg1)->GetMinSize();
46572 wxPyEndAllowThreads(__tstate);
46573 if (PyErr_Occurred()) SWIG_fail;
46574 }
46575 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46576 return resultobj;
46577 fail:
46578 return NULL;
46579 }
46580
46581
46582 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46583 PyObject *resultobj = 0;
46584 wxSizer *arg1 = (wxSizer *) 0 ;
46585 void *argp1 = 0 ;
46586 int res1 = 0 ;
46587 PyObject *swig_obj[1] ;
46588
46589 if (!args) SWIG_fail;
46590 swig_obj[0] = args;
46591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46592 if (!SWIG_IsOK(res1)) {
46593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46594 }
46595 arg1 = reinterpret_cast< wxSizer * >(argp1);
46596 {
46597 PyThreadState* __tstate = wxPyBeginAllowThreads();
46598 (arg1)->RecalcSizes();
46599 wxPyEndAllowThreads(__tstate);
46600 if (PyErr_Occurred()) SWIG_fail;
46601 }
46602 resultobj = SWIG_Py_Void();
46603 return resultobj;
46604 fail:
46605 return NULL;
46606 }
46607
46608
46609 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46610 PyObject *resultobj = 0;
46611 wxSizer *arg1 = (wxSizer *) 0 ;
46612 wxSize result;
46613 void *argp1 = 0 ;
46614 int res1 = 0 ;
46615 PyObject *swig_obj[1] ;
46616
46617 if (!args) SWIG_fail;
46618 swig_obj[0] = args;
46619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46620 if (!SWIG_IsOK(res1)) {
46621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46622 }
46623 arg1 = reinterpret_cast< wxSizer * >(argp1);
46624 {
46625 PyThreadState* __tstate = wxPyBeginAllowThreads();
46626 result = (arg1)->CalcMin();
46627 wxPyEndAllowThreads(__tstate);
46628 if (PyErr_Occurred()) SWIG_fail;
46629 }
46630 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46631 return resultobj;
46632 fail:
46633 return NULL;
46634 }
46635
46636
46637 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46638 PyObject *resultobj = 0;
46639 wxSizer *arg1 = (wxSizer *) 0 ;
46640 void *argp1 = 0 ;
46641 int res1 = 0 ;
46642 PyObject *swig_obj[1] ;
46643
46644 if (!args) SWIG_fail;
46645 swig_obj[0] = args;
46646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46647 if (!SWIG_IsOK(res1)) {
46648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46649 }
46650 arg1 = reinterpret_cast< wxSizer * >(argp1);
46651 {
46652 PyThreadState* __tstate = wxPyBeginAllowThreads();
46653 (arg1)->Layout();
46654 wxPyEndAllowThreads(__tstate);
46655 if (PyErr_Occurred()) SWIG_fail;
46656 }
46657 resultobj = SWIG_Py_Void();
46658 return resultobj;
46659 fail:
46660 return NULL;
46661 }
46662
46663
46664 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46665 PyObject *resultobj = 0;
46666 wxSizer *arg1 = (wxSizer *) 0 ;
46667 wxWindow *arg2 = (wxWindow *) 0 ;
46668 wxSize result;
46669 void *argp1 = 0 ;
46670 int res1 = 0 ;
46671 void *argp2 = 0 ;
46672 int res2 = 0 ;
46673 PyObject * obj0 = 0 ;
46674 PyObject * obj1 = 0 ;
46675 char * kwnames[] = {
46676 (char *) "self",(char *) "window", NULL
46677 };
46678
46679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46681 if (!SWIG_IsOK(res1)) {
46682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46683 }
46684 arg1 = reinterpret_cast< wxSizer * >(argp1);
46685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46686 if (!SWIG_IsOK(res2)) {
46687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46688 }
46689 arg2 = reinterpret_cast< wxWindow * >(argp2);
46690 {
46691 PyThreadState* __tstate = wxPyBeginAllowThreads();
46692 result = (arg1)->Fit(arg2);
46693 wxPyEndAllowThreads(__tstate);
46694 if (PyErr_Occurred()) SWIG_fail;
46695 }
46696 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46697 return resultobj;
46698 fail:
46699 return NULL;
46700 }
46701
46702
46703 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46704 PyObject *resultobj = 0;
46705 wxSizer *arg1 = (wxSizer *) 0 ;
46706 wxWindow *arg2 = (wxWindow *) 0 ;
46707 void *argp1 = 0 ;
46708 int res1 = 0 ;
46709 void *argp2 = 0 ;
46710 int res2 = 0 ;
46711 PyObject * obj0 = 0 ;
46712 PyObject * obj1 = 0 ;
46713 char * kwnames[] = {
46714 (char *) "self",(char *) "window", NULL
46715 };
46716
46717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46719 if (!SWIG_IsOK(res1)) {
46720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46721 }
46722 arg1 = reinterpret_cast< wxSizer * >(argp1);
46723 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46724 if (!SWIG_IsOK(res2)) {
46725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46726 }
46727 arg2 = reinterpret_cast< wxWindow * >(argp2);
46728 {
46729 PyThreadState* __tstate = wxPyBeginAllowThreads();
46730 (arg1)->FitInside(arg2);
46731 wxPyEndAllowThreads(__tstate);
46732 if (PyErr_Occurred()) SWIG_fail;
46733 }
46734 resultobj = SWIG_Py_Void();
46735 return resultobj;
46736 fail:
46737 return NULL;
46738 }
46739
46740
46741 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46742 PyObject *resultobj = 0;
46743 wxSizer *arg1 = (wxSizer *) 0 ;
46744 wxWindow *arg2 = (wxWindow *) 0 ;
46745 void *argp1 = 0 ;
46746 int res1 = 0 ;
46747 void *argp2 = 0 ;
46748 int res2 = 0 ;
46749 PyObject * obj0 = 0 ;
46750 PyObject * obj1 = 0 ;
46751 char * kwnames[] = {
46752 (char *) "self",(char *) "window", NULL
46753 };
46754
46755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46757 if (!SWIG_IsOK(res1)) {
46758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46759 }
46760 arg1 = reinterpret_cast< wxSizer * >(argp1);
46761 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46762 if (!SWIG_IsOK(res2)) {
46763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46764 }
46765 arg2 = reinterpret_cast< wxWindow * >(argp2);
46766 {
46767 PyThreadState* __tstate = wxPyBeginAllowThreads();
46768 (arg1)->SetSizeHints(arg2);
46769 wxPyEndAllowThreads(__tstate);
46770 if (PyErr_Occurred()) SWIG_fail;
46771 }
46772 resultobj = SWIG_Py_Void();
46773 return resultobj;
46774 fail:
46775 return NULL;
46776 }
46777
46778
46779 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46780 PyObject *resultobj = 0;
46781 wxSizer *arg1 = (wxSizer *) 0 ;
46782 wxWindow *arg2 = (wxWindow *) 0 ;
46783 void *argp1 = 0 ;
46784 int res1 = 0 ;
46785 void *argp2 = 0 ;
46786 int res2 = 0 ;
46787 PyObject * obj0 = 0 ;
46788 PyObject * obj1 = 0 ;
46789 char * kwnames[] = {
46790 (char *) "self",(char *) "window", NULL
46791 };
46792
46793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46795 if (!SWIG_IsOK(res1)) {
46796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46797 }
46798 arg1 = reinterpret_cast< wxSizer * >(argp1);
46799 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46800 if (!SWIG_IsOK(res2)) {
46801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46802 }
46803 arg2 = reinterpret_cast< wxWindow * >(argp2);
46804 {
46805 PyThreadState* __tstate = wxPyBeginAllowThreads();
46806 (arg1)->SetVirtualSizeHints(arg2);
46807 wxPyEndAllowThreads(__tstate);
46808 if (PyErr_Occurred()) SWIG_fail;
46809 }
46810 resultobj = SWIG_Py_Void();
46811 return resultobj;
46812 fail:
46813 return NULL;
46814 }
46815
46816
46817 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46818 PyObject *resultobj = 0;
46819 wxSizer *arg1 = (wxSizer *) 0 ;
46820 bool arg2 = (bool) false ;
46821 void *argp1 = 0 ;
46822 int res1 = 0 ;
46823 bool val2 ;
46824 int ecode2 = 0 ;
46825 PyObject * obj0 = 0 ;
46826 PyObject * obj1 = 0 ;
46827 char * kwnames[] = {
46828 (char *) "self",(char *) "deleteWindows", NULL
46829 };
46830
46831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46833 if (!SWIG_IsOK(res1)) {
46834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46835 }
46836 arg1 = reinterpret_cast< wxSizer * >(argp1);
46837 if (obj1) {
46838 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46839 if (!SWIG_IsOK(ecode2)) {
46840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46841 }
46842 arg2 = static_cast< bool >(val2);
46843 }
46844 {
46845 PyThreadState* __tstate = wxPyBeginAllowThreads();
46846 (arg1)->Clear(arg2);
46847 wxPyEndAllowThreads(__tstate);
46848 if (PyErr_Occurred()) SWIG_fail;
46849 }
46850 resultobj = SWIG_Py_Void();
46851 return resultobj;
46852 fail:
46853 return NULL;
46854 }
46855
46856
46857 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46858 PyObject *resultobj = 0;
46859 wxSizer *arg1 = (wxSizer *) 0 ;
46860 void *argp1 = 0 ;
46861 int res1 = 0 ;
46862 PyObject *swig_obj[1] ;
46863
46864 if (!args) SWIG_fail;
46865 swig_obj[0] = args;
46866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46867 if (!SWIG_IsOK(res1)) {
46868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
46869 }
46870 arg1 = reinterpret_cast< wxSizer * >(argp1);
46871 {
46872 PyThreadState* __tstate = wxPyBeginAllowThreads();
46873 (arg1)->DeleteWindows();
46874 wxPyEndAllowThreads(__tstate);
46875 if (PyErr_Occurred()) SWIG_fail;
46876 }
46877 resultobj = SWIG_Py_Void();
46878 return resultobj;
46879 fail:
46880 return NULL;
46881 }
46882
46883
46884 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46885 PyObject *resultobj = 0;
46886 wxSizer *arg1 = (wxSizer *) 0 ;
46887 PyObject *result = 0 ;
46888 void *argp1 = 0 ;
46889 int res1 = 0 ;
46890 PyObject *swig_obj[1] ;
46891
46892 if (!args) SWIG_fail;
46893 swig_obj[0] = args;
46894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46895 if (!SWIG_IsOK(res1)) {
46896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
46897 }
46898 arg1 = reinterpret_cast< wxSizer * >(argp1);
46899 {
46900 PyThreadState* __tstate = wxPyBeginAllowThreads();
46901 result = (PyObject *)wxSizer_GetChildren(arg1);
46902 wxPyEndAllowThreads(__tstate);
46903 if (PyErr_Occurred()) SWIG_fail;
46904 }
46905 resultobj = result;
46906 return resultobj;
46907 fail:
46908 return NULL;
46909 }
46910
46911
46912 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46913 PyObject *resultobj = 0;
46914 wxSizer *arg1 = (wxSizer *) 0 ;
46915 PyObject *arg2 = (PyObject *) 0 ;
46916 bool arg3 = (bool) true ;
46917 bool arg4 = (bool) false ;
46918 bool result;
46919 void *argp1 = 0 ;
46920 int res1 = 0 ;
46921 bool val3 ;
46922 int ecode3 = 0 ;
46923 bool val4 ;
46924 int ecode4 = 0 ;
46925 PyObject * obj0 = 0 ;
46926 PyObject * obj1 = 0 ;
46927 PyObject * obj2 = 0 ;
46928 PyObject * obj3 = 0 ;
46929 char * kwnames[] = {
46930 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
46931 };
46932
46933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
46934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46935 if (!SWIG_IsOK(res1)) {
46936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
46937 }
46938 arg1 = reinterpret_cast< wxSizer * >(argp1);
46939 arg2 = obj1;
46940 if (obj2) {
46941 ecode3 = SWIG_AsVal_bool(obj2, &val3);
46942 if (!SWIG_IsOK(ecode3)) {
46943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
46944 }
46945 arg3 = static_cast< bool >(val3);
46946 }
46947 if (obj3) {
46948 ecode4 = SWIG_AsVal_bool(obj3, &val4);
46949 if (!SWIG_IsOK(ecode4)) {
46950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
46951 }
46952 arg4 = static_cast< bool >(val4);
46953 }
46954 {
46955 PyThreadState* __tstate = wxPyBeginAllowThreads();
46956 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
46957 wxPyEndAllowThreads(__tstate);
46958 if (PyErr_Occurred()) SWIG_fail;
46959 }
46960 {
46961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46962 }
46963 return resultobj;
46964 fail:
46965 return NULL;
46966 }
46967
46968
46969 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46970 PyObject *resultobj = 0;
46971 wxSizer *arg1 = (wxSizer *) 0 ;
46972 PyObject *arg2 = (PyObject *) 0 ;
46973 bool result;
46974 void *argp1 = 0 ;
46975 int res1 = 0 ;
46976 PyObject * obj0 = 0 ;
46977 PyObject * obj1 = 0 ;
46978 char * kwnames[] = {
46979 (char *) "self",(char *) "item", NULL
46980 };
46981
46982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
46983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46984 if (!SWIG_IsOK(res1)) {
46985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
46986 }
46987 arg1 = reinterpret_cast< wxSizer * >(argp1);
46988 arg2 = obj1;
46989 {
46990 PyThreadState* __tstate = wxPyBeginAllowThreads();
46991 result = (bool)wxSizer_IsShown(arg1,arg2);
46992 wxPyEndAllowThreads(__tstate);
46993 if (PyErr_Occurred()) SWIG_fail;
46994 }
46995 {
46996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46997 }
46998 return resultobj;
46999 fail:
47000 return NULL;
47001 }
47002
47003
47004 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47005 PyObject *resultobj = 0;
47006 wxSizer *arg1 = (wxSizer *) 0 ;
47007 bool arg2 ;
47008 void *argp1 = 0 ;
47009 int res1 = 0 ;
47010 bool val2 ;
47011 int ecode2 = 0 ;
47012 PyObject * obj0 = 0 ;
47013 PyObject * obj1 = 0 ;
47014 char * kwnames[] = {
47015 (char *) "self",(char *) "show", NULL
47016 };
47017
47018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47020 if (!SWIG_IsOK(res1)) {
47021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47022 }
47023 arg1 = reinterpret_cast< wxSizer * >(argp1);
47024 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47025 if (!SWIG_IsOK(ecode2)) {
47026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47027 }
47028 arg2 = static_cast< bool >(val2);
47029 {
47030 PyThreadState* __tstate = wxPyBeginAllowThreads();
47031 (arg1)->ShowItems(arg2);
47032 wxPyEndAllowThreads(__tstate);
47033 if (PyErr_Occurred()) SWIG_fail;
47034 }
47035 resultobj = SWIG_Py_Void();
47036 return resultobj;
47037 fail:
47038 return NULL;
47039 }
47040
47041
47042 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47043 PyObject *obj;
47044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47045 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47046 return SWIG_Py_Void();
47047 }
47048
47049 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47050 PyObject *resultobj = 0;
47051 wxPySizer *result = 0 ;
47052
47053 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47054 {
47055 PyThreadState* __tstate = wxPyBeginAllowThreads();
47056 result = (wxPySizer *)new wxPySizer();
47057 wxPyEndAllowThreads(__tstate);
47058 if (PyErr_Occurred()) SWIG_fail;
47059 }
47060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47061 return resultobj;
47062 fail:
47063 return NULL;
47064 }
47065
47066
47067 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47068 PyObject *resultobj = 0;
47069 wxPySizer *arg1 = (wxPySizer *) 0 ;
47070 PyObject *arg2 = (PyObject *) 0 ;
47071 PyObject *arg3 = (PyObject *) 0 ;
47072 void *argp1 = 0 ;
47073 int res1 = 0 ;
47074 PyObject * obj0 = 0 ;
47075 PyObject * obj1 = 0 ;
47076 PyObject * obj2 = 0 ;
47077 char * kwnames[] = {
47078 (char *) "self",(char *) "self",(char *) "_class", NULL
47079 };
47080
47081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47083 if (!SWIG_IsOK(res1)) {
47084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47085 }
47086 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47087 arg2 = obj1;
47088 arg3 = obj2;
47089 {
47090 PyThreadState* __tstate = wxPyBeginAllowThreads();
47091 (arg1)->_setCallbackInfo(arg2,arg3);
47092 wxPyEndAllowThreads(__tstate);
47093 if (PyErr_Occurred()) SWIG_fail;
47094 }
47095 resultobj = SWIG_Py_Void();
47096 return resultobj;
47097 fail:
47098 return NULL;
47099 }
47100
47101
47102 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47103 PyObject *obj;
47104 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47105 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47106 return SWIG_Py_Void();
47107 }
47108
47109 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47110 return SWIG_Python_InitShadowInstance(args);
47111 }
47112
47113 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47114 PyObject *resultobj = 0;
47115 int arg1 = (int) wxHORIZONTAL ;
47116 wxBoxSizer *result = 0 ;
47117 int val1 ;
47118 int ecode1 = 0 ;
47119 PyObject * obj0 = 0 ;
47120 char * kwnames[] = {
47121 (char *) "orient", NULL
47122 };
47123
47124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47125 if (obj0) {
47126 ecode1 = SWIG_AsVal_int(obj0, &val1);
47127 if (!SWIG_IsOK(ecode1)) {
47128 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47129 }
47130 arg1 = static_cast< int >(val1);
47131 }
47132 {
47133 PyThreadState* __tstate = wxPyBeginAllowThreads();
47134 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47135 wxPyEndAllowThreads(__tstate);
47136 if (PyErr_Occurred()) SWIG_fail;
47137 }
47138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47139 return resultobj;
47140 fail:
47141 return NULL;
47142 }
47143
47144
47145 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47146 PyObject *resultobj = 0;
47147 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47148 int result;
47149 void *argp1 = 0 ;
47150 int res1 = 0 ;
47151 PyObject *swig_obj[1] ;
47152
47153 if (!args) SWIG_fail;
47154 swig_obj[0] = args;
47155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47156 if (!SWIG_IsOK(res1)) {
47157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47158 }
47159 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47160 {
47161 PyThreadState* __tstate = wxPyBeginAllowThreads();
47162 result = (int)(arg1)->GetOrientation();
47163 wxPyEndAllowThreads(__tstate);
47164 if (PyErr_Occurred()) SWIG_fail;
47165 }
47166 resultobj = SWIG_From_int(static_cast< int >(result));
47167 return resultobj;
47168 fail:
47169 return NULL;
47170 }
47171
47172
47173 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47174 PyObject *resultobj = 0;
47175 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47176 int arg2 ;
47177 void *argp1 = 0 ;
47178 int res1 = 0 ;
47179 int val2 ;
47180 int ecode2 = 0 ;
47181 PyObject * obj0 = 0 ;
47182 PyObject * obj1 = 0 ;
47183 char * kwnames[] = {
47184 (char *) "self",(char *) "orient", NULL
47185 };
47186
47187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47189 if (!SWIG_IsOK(res1)) {
47190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47191 }
47192 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47193 ecode2 = SWIG_AsVal_int(obj1, &val2);
47194 if (!SWIG_IsOK(ecode2)) {
47195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47196 }
47197 arg2 = static_cast< int >(val2);
47198 {
47199 PyThreadState* __tstate = wxPyBeginAllowThreads();
47200 (arg1)->SetOrientation(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 *BoxSizer_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_wxBoxSizer, SWIG_NewClientData(obj));
47215 return SWIG_Py_Void();
47216 }
47217
47218 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47219 return SWIG_Python_InitShadowInstance(args);
47220 }
47221
47222 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47223 PyObject *resultobj = 0;
47224 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47225 int arg2 = (int) wxHORIZONTAL ;
47226 wxStaticBoxSizer *result = 0 ;
47227 void *argp1 = 0 ;
47228 int res1 = 0 ;
47229 int val2 ;
47230 int ecode2 = 0 ;
47231 PyObject * obj0 = 0 ;
47232 PyObject * obj1 = 0 ;
47233 char * kwnames[] = {
47234 (char *) "box",(char *) "orient", NULL
47235 };
47236
47237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47239 if (!SWIG_IsOK(res1)) {
47240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47241 }
47242 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47243 if (obj1) {
47244 ecode2 = SWIG_AsVal_int(obj1, &val2);
47245 if (!SWIG_IsOK(ecode2)) {
47246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47247 }
47248 arg2 = static_cast< int >(val2);
47249 }
47250 {
47251 PyThreadState* __tstate = wxPyBeginAllowThreads();
47252 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47253 wxPyEndAllowThreads(__tstate);
47254 if (PyErr_Occurred()) SWIG_fail;
47255 }
47256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47257 return resultobj;
47258 fail:
47259 return NULL;
47260 }
47261
47262
47263 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47264 PyObject *resultobj = 0;
47265 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47266 wxStaticBox *result = 0 ;
47267 void *argp1 = 0 ;
47268 int res1 = 0 ;
47269 PyObject *swig_obj[1] ;
47270
47271 if (!args) SWIG_fail;
47272 swig_obj[0] = args;
47273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47274 if (!SWIG_IsOK(res1)) {
47275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47276 }
47277 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47278 {
47279 PyThreadState* __tstate = wxPyBeginAllowThreads();
47280 result = (wxStaticBox *)(arg1)->GetStaticBox();
47281 wxPyEndAllowThreads(__tstate);
47282 if (PyErr_Occurred()) SWIG_fail;
47283 }
47284 {
47285 resultobj = wxPyMake_wxObject(result, (bool)0);
47286 }
47287 return resultobj;
47288 fail:
47289 return NULL;
47290 }
47291
47292
47293 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47294 PyObject *obj;
47295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47296 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47297 return SWIG_Py_Void();
47298 }
47299
47300 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47301 return SWIG_Python_InitShadowInstance(args);
47302 }
47303
47304 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47305 PyObject *resultobj = 0;
47306 int arg1 = (int) 1 ;
47307 int arg2 = (int) 0 ;
47308 int arg3 = (int) 0 ;
47309 int arg4 = (int) 0 ;
47310 wxGridSizer *result = 0 ;
47311 int val1 ;
47312 int ecode1 = 0 ;
47313 int val2 ;
47314 int ecode2 = 0 ;
47315 int val3 ;
47316 int ecode3 = 0 ;
47317 int val4 ;
47318 int ecode4 = 0 ;
47319 PyObject * obj0 = 0 ;
47320 PyObject * obj1 = 0 ;
47321 PyObject * obj2 = 0 ;
47322 PyObject * obj3 = 0 ;
47323 char * kwnames[] = {
47324 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47325 };
47326
47327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47328 if (obj0) {
47329 ecode1 = SWIG_AsVal_int(obj0, &val1);
47330 if (!SWIG_IsOK(ecode1)) {
47331 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47332 }
47333 arg1 = static_cast< int >(val1);
47334 }
47335 if (obj1) {
47336 ecode2 = SWIG_AsVal_int(obj1, &val2);
47337 if (!SWIG_IsOK(ecode2)) {
47338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47339 }
47340 arg2 = static_cast< int >(val2);
47341 }
47342 if (obj2) {
47343 ecode3 = SWIG_AsVal_int(obj2, &val3);
47344 if (!SWIG_IsOK(ecode3)) {
47345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47346 }
47347 arg3 = static_cast< int >(val3);
47348 }
47349 if (obj3) {
47350 ecode4 = SWIG_AsVal_int(obj3, &val4);
47351 if (!SWIG_IsOK(ecode4)) {
47352 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47353 }
47354 arg4 = static_cast< int >(val4);
47355 }
47356 {
47357 PyThreadState* __tstate = wxPyBeginAllowThreads();
47358 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47359 wxPyEndAllowThreads(__tstate);
47360 if (PyErr_Occurred()) SWIG_fail;
47361 }
47362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47363 return resultobj;
47364 fail:
47365 return NULL;
47366 }
47367
47368
47369 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47370 PyObject *resultobj = 0;
47371 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47372 int arg2 ;
47373 void *argp1 = 0 ;
47374 int res1 = 0 ;
47375 int val2 ;
47376 int ecode2 = 0 ;
47377 PyObject * obj0 = 0 ;
47378 PyObject * obj1 = 0 ;
47379 char * kwnames[] = {
47380 (char *) "self",(char *) "cols", NULL
47381 };
47382
47383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47385 if (!SWIG_IsOK(res1)) {
47386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47387 }
47388 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47389 ecode2 = SWIG_AsVal_int(obj1, &val2);
47390 if (!SWIG_IsOK(ecode2)) {
47391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47392 }
47393 arg2 = static_cast< int >(val2);
47394 {
47395 PyThreadState* __tstate = wxPyBeginAllowThreads();
47396 (arg1)->SetCols(arg2);
47397 wxPyEndAllowThreads(__tstate);
47398 if (PyErr_Occurred()) SWIG_fail;
47399 }
47400 resultobj = SWIG_Py_Void();
47401 return resultobj;
47402 fail:
47403 return NULL;
47404 }
47405
47406
47407 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47408 PyObject *resultobj = 0;
47409 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47410 int arg2 ;
47411 void *argp1 = 0 ;
47412 int res1 = 0 ;
47413 int val2 ;
47414 int ecode2 = 0 ;
47415 PyObject * obj0 = 0 ;
47416 PyObject * obj1 = 0 ;
47417 char * kwnames[] = {
47418 (char *) "self",(char *) "rows", NULL
47419 };
47420
47421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47423 if (!SWIG_IsOK(res1)) {
47424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47425 }
47426 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47427 ecode2 = SWIG_AsVal_int(obj1, &val2);
47428 if (!SWIG_IsOK(ecode2)) {
47429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47430 }
47431 arg2 = static_cast< int >(val2);
47432 {
47433 PyThreadState* __tstate = wxPyBeginAllowThreads();
47434 (arg1)->SetRows(arg2);
47435 wxPyEndAllowThreads(__tstate);
47436 if (PyErr_Occurred()) SWIG_fail;
47437 }
47438 resultobj = SWIG_Py_Void();
47439 return resultobj;
47440 fail:
47441 return NULL;
47442 }
47443
47444
47445 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47446 PyObject *resultobj = 0;
47447 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47448 int arg2 ;
47449 void *argp1 = 0 ;
47450 int res1 = 0 ;
47451 int val2 ;
47452 int ecode2 = 0 ;
47453 PyObject * obj0 = 0 ;
47454 PyObject * obj1 = 0 ;
47455 char * kwnames[] = {
47456 (char *) "self",(char *) "gap", NULL
47457 };
47458
47459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47461 if (!SWIG_IsOK(res1)) {
47462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47463 }
47464 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47465 ecode2 = SWIG_AsVal_int(obj1, &val2);
47466 if (!SWIG_IsOK(ecode2)) {
47467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47468 }
47469 arg2 = static_cast< int >(val2);
47470 {
47471 PyThreadState* __tstate = wxPyBeginAllowThreads();
47472 (arg1)->SetVGap(arg2);
47473 wxPyEndAllowThreads(__tstate);
47474 if (PyErr_Occurred()) SWIG_fail;
47475 }
47476 resultobj = SWIG_Py_Void();
47477 return resultobj;
47478 fail:
47479 return NULL;
47480 }
47481
47482
47483 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47484 PyObject *resultobj = 0;
47485 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47486 int arg2 ;
47487 void *argp1 = 0 ;
47488 int res1 = 0 ;
47489 int val2 ;
47490 int ecode2 = 0 ;
47491 PyObject * obj0 = 0 ;
47492 PyObject * obj1 = 0 ;
47493 char * kwnames[] = {
47494 (char *) "self",(char *) "gap", NULL
47495 };
47496
47497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47499 if (!SWIG_IsOK(res1)) {
47500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47501 }
47502 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47503 ecode2 = SWIG_AsVal_int(obj1, &val2);
47504 if (!SWIG_IsOK(ecode2)) {
47505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47506 }
47507 arg2 = static_cast< int >(val2);
47508 {
47509 PyThreadState* __tstate = wxPyBeginAllowThreads();
47510 (arg1)->SetHGap(arg2);
47511 wxPyEndAllowThreads(__tstate);
47512 if (PyErr_Occurred()) SWIG_fail;
47513 }
47514 resultobj = SWIG_Py_Void();
47515 return resultobj;
47516 fail:
47517 return NULL;
47518 }
47519
47520
47521 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47522 PyObject *resultobj = 0;
47523 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47524 int result;
47525 void *argp1 = 0 ;
47526 int res1 = 0 ;
47527 PyObject *swig_obj[1] ;
47528
47529 if (!args) SWIG_fail;
47530 swig_obj[0] = args;
47531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47532 if (!SWIG_IsOK(res1)) {
47533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47534 }
47535 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47536 {
47537 PyThreadState* __tstate = wxPyBeginAllowThreads();
47538 result = (int)(arg1)->GetCols();
47539 wxPyEndAllowThreads(__tstate);
47540 if (PyErr_Occurred()) SWIG_fail;
47541 }
47542 resultobj = SWIG_From_int(static_cast< int >(result));
47543 return resultobj;
47544 fail:
47545 return NULL;
47546 }
47547
47548
47549 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47550 PyObject *resultobj = 0;
47551 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47552 int result;
47553 void *argp1 = 0 ;
47554 int res1 = 0 ;
47555 PyObject *swig_obj[1] ;
47556
47557 if (!args) SWIG_fail;
47558 swig_obj[0] = args;
47559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47560 if (!SWIG_IsOK(res1)) {
47561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47562 }
47563 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47564 {
47565 PyThreadState* __tstate = wxPyBeginAllowThreads();
47566 result = (int)(arg1)->GetRows();
47567 wxPyEndAllowThreads(__tstate);
47568 if (PyErr_Occurred()) SWIG_fail;
47569 }
47570 resultobj = SWIG_From_int(static_cast< int >(result));
47571 return resultobj;
47572 fail:
47573 return NULL;
47574 }
47575
47576
47577 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47578 PyObject *resultobj = 0;
47579 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47580 int result;
47581 void *argp1 = 0 ;
47582 int res1 = 0 ;
47583 PyObject *swig_obj[1] ;
47584
47585 if (!args) SWIG_fail;
47586 swig_obj[0] = args;
47587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47588 if (!SWIG_IsOK(res1)) {
47589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47590 }
47591 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47592 {
47593 PyThreadState* __tstate = wxPyBeginAllowThreads();
47594 result = (int)(arg1)->GetVGap();
47595 wxPyEndAllowThreads(__tstate);
47596 if (PyErr_Occurred()) SWIG_fail;
47597 }
47598 resultobj = SWIG_From_int(static_cast< int >(result));
47599 return resultobj;
47600 fail:
47601 return NULL;
47602 }
47603
47604
47605 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47606 PyObject *resultobj = 0;
47607 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47608 int result;
47609 void *argp1 = 0 ;
47610 int res1 = 0 ;
47611 PyObject *swig_obj[1] ;
47612
47613 if (!args) SWIG_fail;
47614 swig_obj[0] = args;
47615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47616 if (!SWIG_IsOK(res1)) {
47617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47618 }
47619 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47620 {
47621 PyThreadState* __tstate = wxPyBeginAllowThreads();
47622 result = (int)(arg1)->GetHGap();
47623 wxPyEndAllowThreads(__tstate);
47624 if (PyErr_Occurred()) SWIG_fail;
47625 }
47626 resultobj = SWIG_From_int(static_cast< int >(result));
47627 return resultobj;
47628 fail:
47629 return NULL;
47630 }
47631
47632
47633 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47634 PyObject *obj;
47635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47636 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47637 return SWIG_Py_Void();
47638 }
47639
47640 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47641 return SWIG_Python_InitShadowInstance(args);
47642 }
47643
47644 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47645 PyObject *resultobj = 0;
47646 int arg1 = (int) 1 ;
47647 int arg2 = (int) 0 ;
47648 int arg3 = (int) 0 ;
47649 int arg4 = (int) 0 ;
47650 wxFlexGridSizer *result = 0 ;
47651 int val1 ;
47652 int ecode1 = 0 ;
47653 int val2 ;
47654 int ecode2 = 0 ;
47655 int val3 ;
47656 int ecode3 = 0 ;
47657 int val4 ;
47658 int ecode4 = 0 ;
47659 PyObject * obj0 = 0 ;
47660 PyObject * obj1 = 0 ;
47661 PyObject * obj2 = 0 ;
47662 PyObject * obj3 = 0 ;
47663 char * kwnames[] = {
47664 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47665 };
47666
47667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47668 if (obj0) {
47669 ecode1 = SWIG_AsVal_int(obj0, &val1);
47670 if (!SWIG_IsOK(ecode1)) {
47671 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47672 }
47673 arg1 = static_cast< int >(val1);
47674 }
47675 if (obj1) {
47676 ecode2 = SWIG_AsVal_int(obj1, &val2);
47677 if (!SWIG_IsOK(ecode2)) {
47678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47679 }
47680 arg2 = static_cast< int >(val2);
47681 }
47682 if (obj2) {
47683 ecode3 = SWIG_AsVal_int(obj2, &val3);
47684 if (!SWIG_IsOK(ecode3)) {
47685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47686 }
47687 arg3 = static_cast< int >(val3);
47688 }
47689 if (obj3) {
47690 ecode4 = SWIG_AsVal_int(obj3, &val4);
47691 if (!SWIG_IsOK(ecode4)) {
47692 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47693 }
47694 arg4 = static_cast< int >(val4);
47695 }
47696 {
47697 PyThreadState* __tstate = wxPyBeginAllowThreads();
47698 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47699 wxPyEndAllowThreads(__tstate);
47700 if (PyErr_Occurred()) SWIG_fail;
47701 }
47702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47703 return resultobj;
47704 fail:
47705 return NULL;
47706 }
47707
47708
47709 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47710 PyObject *resultobj = 0;
47711 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47712 size_t arg2 ;
47713 int arg3 = (int) 0 ;
47714 void *argp1 = 0 ;
47715 int res1 = 0 ;
47716 size_t val2 ;
47717 int ecode2 = 0 ;
47718 int val3 ;
47719 int ecode3 = 0 ;
47720 PyObject * obj0 = 0 ;
47721 PyObject * obj1 = 0 ;
47722 PyObject * obj2 = 0 ;
47723 char * kwnames[] = {
47724 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47725 };
47726
47727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47729 if (!SWIG_IsOK(res1)) {
47730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47731 }
47732 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47733 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47734 if (!SWIG_IsOK(ecode2)) {
47735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47736 }
47737 arg2 = static_cast< size_t >(val2);
47738 if (obj2) {
47739 ecode3 = SWIG_AsVal_int(obj2, &val3);
47740 if (!SWIG_IsOK(ecode3)) {
47741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47742 }
47743 arg3 = static_cast< int >(val3);
47744 }
47745 {
47746 PyThreadState* __tstate = wxPyBeginAllowThreads();
47747 (arg1)->AddGrowableRow(arg2,arg3);
47748 wxPyEndAllowThreads(__tstate);
47749 if (PyErr_Occurred()) SWIG_fail;
47750 }
47751 resultobj = SWIG_Py_Void();
47752 return resultobj;
47753 fail:
47754 return NULL;
47755 }
47756
47757
47758 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47759 PyObject *resultobj = 0;
47760 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47761 size_t arg2 ;
47762 void *argp1 = 0 ;
47763 int res1 = 0 ;
47764 size_t val2 ;
47765 int ecode2 = 0 ;
47766 PyObject * obj0 = 0 ;
47767 PyObject * obj1 = 0 ;
47768 char * kwnames[] = {
47769 (char *) "self",(char *) "idx", NULL
47770 };
47771
47772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47774 if (!SWIG_IsOK(res1)) {
47775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47776 }
47777 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47778 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47779 if (!SWIG_IsOK(ecode2)) {
47780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47781 }
47782 arg2 = static_cast< size_t >(val2);
47783 {
47784 PyThreadState* __tstate = wxPyBeginAllowThreads();
47785 (arg1)->RemoveGrowableRow(arg2);
47786 wxPyEndAllowThreads(__tstate);
47787 if (PyErr_Occurred()) SWIG_fail;
47788 }
47789 resultobj = SWIG_Py_Void();
47790 return resultobj;
47791 fail:
47792 return NULL;
47793 }
47794
47795
47796 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47797 PyObject *resultobj = 0;
47798 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47799 size_t arg2 ;
47800 int arg3 = (int) 0 ;
47801 void *argp1 = 0 ;
47802 int res1 = 0 ;
47803 size_t val2 ;
47804 int ecode2 = 0 ;
47805 int val3 ;
47806 int ecode3 = 0 ;
47807 PyObject * obj0 = 0 ;
47808 PyObject * obj1 = 0 ;
47809 PyObject * obj2 = 0 ;
47810 char * kwnames[] = {
47811 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47812 };
47813
47814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47816 if (!SWIG_IsOK(res1)) {
47817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47818 }
47819 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47820 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47821 if (!SWIG_IsOK(ecode2)) {
47822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47823 }
47824 arg2 = static_cast< size_t >(val2);
47825 if (obj2) {
47826 ecode3 = SWIG_AsVal_int(obj2, &val3);
47827 if (!SWIG_IsOK(ecode3)) {
47828 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47829 }
47830 arg3 = static_cast< int >(val3);
47831 }
47832 {
47833 PyThreadState* __tstate = wxPyBeginAllowThreads();
47834 (arg1)->AddGrowableCol(arg2,arg3);
47835 wxPyEndAllowThreads(__tstate);
47836 if (PyErr_Occurred()) SWIG_fail;
47837 }
47838 resultobj = SWIG_Py_Void();
47839 return resultobj;
47840 fail:
47841 return NULL;
47842 }
47843
47844
47845 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47846 PyObject *resultobj = 0;
47847 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47848 size_t arg2 ;
47849 void *argp1 = 0 ;
47850 int res1 = 0 ;
47851 size_t val2 ;
47852 int ecode2 = 0 ;
47853 PyObject * obj0 = 0 ;
47854 PyObject * obj1 = 0 ;
47855 char * kwnames[] = {
47856 (char *) "self",(char *) "idx", NULL
47857 };
47858
47859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
47860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47861 if (!SWIG_IsOK(res1)) {
47862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47863 }
47864 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47865 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47866 if (!SWIG_IsOK(ecode2)) {
47867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47868 }
47869 arg2 = static_cast< size_t >(val2);
47870 {
47871 PyThreadState* __tstate = wxPyBeginAllowThreads();
47872 (arg1)->RemoveGrowableCol(arg2);
47873 wxPyEndAllowThreads(__tstate);
47874 if (PyErr_Occurred()) SWIG_fail;
47875 }
47876 resultobj = SWIG_Py_Void();
47877 return resultobj;
47878 fail:
47879 return NULL;
47880 }
47881
47882
47883 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47884 PyObject *resultobj = 0;
47885 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47886 int arg2 ;
47887 void *argp1 = 0 ;
47888 int res1 = 0 ;
47889 int val2 ;
47890 int ecode2 = 0 ;
47891 PyObject * obj0 = 0 ;
47892 PyObject * obj1 = 0 ;
47893 char * kwnames[] = {
47894 (char *) "self",(char *) "direction", NULL
47895 };
47896
47897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
47898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47899 if (!SWIG_IsOK(res1)) {
47900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47901 }
47902 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47903 ecode2 = SWIG_AsVal_int(obj1, &val2);
47904 if (!SWIG_IsOK(ecode2)) {
47905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
47906 }
47907 arg2 = static_cast< int >(val2);
47908 {
47909 PyThreadState* __tstate = wxPyBeginAllowThreads();
47910 (arg1)->SetFlexibleDirection(arg2);
47911 wxPyEndAllowThreads(__tstate);
47912 if (PyErr_Occurred()) SWIG_fail;
47913 }
47914 resultobj = SWIG_Py_Void();
47915 return resultobj;
47916 fail:
47917 return NULL;
47918 }
47919
47920
47921 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47922 PyObject *resultobj = 0;
47923 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47924 int result;
47925 void *argp1 = 0 ;
47926 int res1 = 0 ;
47927 PyObject *swig_obj[1] ;
47928
47929 if (!args) SWIG_fail;
47930 swig_obj[0] = args;
47931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47932 if (!SWIG_IsOK(res1)) {
47933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47934 }
47935 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47936 {
47937 PyThreadState* __tstate = wxPyBeginAllowThreads();
47938 result = (int)(arg1)->GetFlexibleDirection();
47939 wxPyEndAllowThreads(__tstate);
47940 if (PyErr_Occurred()) SWIG_fail;
47941 }
47942 resultobj = SWIG_From_int(static_cast< int >(result));
47943 return resultobj;
47944 fail:
47945 return NULL;
47946 }
47947
47948
47949 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47950 PyObject *resultobj = 0;
47951 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47952 wxFlexSizerGrowMode arg2 ;
47953 void *argp1 = 0 ;
47954 int res1 = 0 ;
47955 int val2 ;
47956 int ecode2 = 0 ;
47957 PyObject * obj0 = 0 ;
47958 PyObject * obj1 = 0 ;
47959 char * kwnames[] = {
47960 (char *) "self",(char *) "mode", NULL
47961 };
47962
47963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
47964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47965 if (!SWIG_IsOK(res1)) {
47966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47967 }
47968 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47969 ecode2 = SWIG_AsVal_int(obj1, &val2);
47970 if (!SWIG_IsOK(ecode2)) {
47971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
47972 }
47973 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
47974 {
47975 PyThreadState* __tstate = wxPyBeginAllowThreads();
47976 (arg1)->SetNonFlexibleGrowMode(arg2);
47977 wxPyEndAllowThreads(__tstate);
47978 if (PyErr_Occurred()) SWIG_fail;
47979 }
47980 resultobj = SWIG_Py_Void();
47981 return resultobj;
47982 fail:
47983 return NULL;
47984 }
47985
47986
47987 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47988 PyObject *resultobj = 0;
47989 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47990 wxFlexSizerGrowMode result;
47991 void *argp1 = 0 ;
47992 int res1 = 0 ;
47993 PyObject *swig_obj[1] ;
47994
47995 if (!args) SWIG_fail;
47996 swig_obj[0] = args;
47997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47998 if (!SWIG_IsOK(res1)) {
47999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48000 }
48001 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48002 {
48003 PyThreadState* __tstate = wxPyBeginAllowThreads();
48004 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48005 wxPyEndAllowThreads(__tstate);
48006 if (PyErr_Occurred()) SWIG_fail;
48007 }
48008 resultobj = SWIG_From_int(static_cast< int >(result));
48009 return resultobj;
48010 fail:
48011 return NULL;
48012 }
48013
48014
48015 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48016 PyObject *resultobj = 0;
48017 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48018 wxArrayInt *result = 0 ;
48019 void *argp1 = 0 ;
48020 int res1 = 0 ;
48021 PyObject *swig_obj[1] ;
48022
48023 if (!args) SWIG_fail;
48024 swig_obj[0] = args;
48025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48026 if (!SWIG_IsOK(res1)) {
48027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48028 }
48029 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48030 {
48031 PyThreadState* __tstate = wxPyBeginAllowThreads();
48032 {
48033 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48034 result = (wxArrayInt *) &_result_ref;
48035 }
48036 wxPyEndAllowThreads(__tstate);
48037 if (PyErr_Occurred()) SWIG_fail;
48038 }
48039 {
48040 resultobj = PyList_New(0);
48041 size_t idx;
48042 for (idx = 0; idx < result->GetCount(); idx += 1) {
48043 PyObject* val = PyInt_FromLong( result->Item(idx) );
48044 PyList_Append(resultobj, val);
48045 Py_DECREF(val);
48046 }
48047 }
48048 return resultobj;
48049 fail:
48050 return NULL;
48051 }
48052
48053
48054 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48055 PyObject *resultobj = 0;
48056 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48057 wxArrayInt *result = 0 ;
48058 void *argp1 = 0 ;
48059 int res1 = 0 ;
48060 PyObject *swig_obj[1] ;
48061
48062 if (!args) SWIG_fail;
48063 swig_obj[0] = args;
48064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48065 if (!SWIG_IsOK(res1)) {
48066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48067 }
48068 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48069 {
48070 PyThreadState* __tstate = wxPyBeginAllowThreads();
48071 {
48072 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48073 result = (wxArrayInt *) &_result_ref;
48074 }
48075 wxPyEndAllowThreads(__tstate);
48076 if (PyErr_Occurred()) SWIG_fail;
48077 }
48078 {
48079 resultobj = PyList_New(0);
48080 size_t idx;
48081 for (idx = 0; idx < result->GetCount(); idx += 1) {
48082 PyObject* val = PyInt_FromLong( result->Item(idx) );
48083 PyList_Append(resultobj, val);
48084 Py_DECREF(val);
48085 }
48086 }
48087 return resultobj;
48088 fail:
48089 return NULL;
48090 }
48091
48092
48093 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48094 PyObject *obj;
48095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48096 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48097 return SWIG_Py_Void();
48098 }
48099
48100 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48101 return SWIG_Python_InitShadowInstance(args);
48102 }
48103
48104 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48105 PyObject *resultobj = 0;
48106 wxStdDialogButtonSizer *result = 0 ;
48107
48108 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48109 {
48110 PyThreadState* __tstate = wxPyBeginAllowThreads();
48111 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48112 wxPyEndAllowThreads(__tstate);
48113 if (PyErr_Occurred()) SWIG_fail;
48114 }
48115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48116 return resultobj;
48117 fail:
48118 return NULL;
48119 }
48120
48121
48122 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48123 PyObject *resultobj = 0;
48124 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48125 wxButton *arg2 = (wxButton *) 0 ;
48126 void *argp1 = 0 ;
48127 int res1 = 0 ;
48128 void *argp2 = 0 ;
48129 int res2 = 0 ;
48130 PyObject * obj0 = 0 ;
48131 PyObject * obj1 = 0 ;
48132 char * kwnames[] = {
48133 (char *) "self",(char *) "button", NULL
48134 };
48135
48136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48138 if (!SWIG_IsOK(res1)) {
48139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48140 }
48141 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48143 if (!SWIG_IsOK(res2)) {
48144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48145 }
48146 arg2 = reinterpret_cast< wxButton * >(argp2);
48147 {
48148 PyThreadState* __tstate = wxPyBeginAllowThreads();
48149 (arg1)->AddButton(arg2);
48150 wxPyEndAllowThreads(__tstate);
48151 if (PyErr_Occurred()) SWIG_fail;
48152 }
48153 resultobj = SWIG_Py_Void();
48154 return resultobj;
48155 fail:
48156 return NULL;
48157 }
48158
48159
48160 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48161 PyObject *resultobj = 0;
48162 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48163 void *argp1 = 0 ;
48164 int res1 = 0 ;
48165 PyObject *swig_obj[1] ;
48166
48167 if (!args) SWIG_fail;
48168 swig_obj[0] = args;
48169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48170 if (!SWIG_IsOK(res1)) {
48171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48172 }
48173 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48174 {
48175 PyThreadState* __tstate = wxPyBeginAllowThreads();
48176 (arg1)->Realize();
48177 wxPyEndAllowThreads(__tstate);
48178 if (PyErr_Occurred()) SWIG_fail;
48179 }
48180 resultobj = SWIG_Py_Void();
48181 return resultobj;
48182 fail:
48183 return NULL;
48184 }
48185
48186
48187 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48188 PyObject *resultobj = 0;
48189 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48190 wxButton *arg2 = (wxButton *) 0 ;
48191 void *argp1 = 0 ;
48192 int res1 = 0 ;
48193 void *argp2 = 0 ;
48194 int res2 = 0 ;
48195 PyObject * obj0 = 0 ;
48196 PyObject * obj1 = 0 ;
48197 char * kwnames[] = {
48198 (char *) "self",(char *) "button", NULL
48199 };
48200
48201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48203 if (!SWIG_IsOK(res1)) {
48204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48205 }
48206 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48207 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48208 if (!SWIG_IsOK(res2)) {
48209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48210 }
48211 arg2 = reinterpret_cast< wxButton * >(argp2);
48212 {
48213 PyThreadState* __tstate = wxPyBeginAllowThreads();
48214 (arg1)->SetAffirmativeButton(arg2);
48215 wxPyEndAllowThreads(__tstate);
48216 if (PyErr_Occurred()) SWIG_fail;
48217 }
48218 resultobj = SWIG_Py_Void();
48219 return resultobj;
48220 fail:
48221 return NULL;
48222 }
48223
48224
48225 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48226 PyObject *resultobj = 0;
48227 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48228 wxButton *arg2 = (wxButton *) 0 ;
48229 void *argp1 = 0 ;
48230 int res1 = 0 ;
48231 void *argp2 = 0 ;
48232 int res2 = 0 ;
48233 PyObject * obj0 = 0 ;
48234 PyObject * obj1 = 0 ;
48235 char * kwnames[] = {
48236 (char *) "self",(char *) "button", NULL
48237 };
48238
48239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48241 if (!SWIG_IsOK(res1)) {
48242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48243 }
48244 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48246 if (!SWIG_IsOK(res2)) {
48247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48248 }
48249 arg2 = reinterpret_cast< wxButton * >(argp2);
48250 {
48251 PyThreadState* __tstate = wxPyBeginAllowThreads();
48252 (arg1)->SetNegativeButton(arg2);
48253 wxPyEndAllowThreads(__tstate);
48254 if (PyErr_Occurred()) SWIG_fail;
48255 }
48256 resultobj = SWIG_Py_Void();
48257 return resultobj;
48258 fail:
48259 return NULL;
48260 }
48261
48262
48263 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48264 PyObject *resultobj = 0;
48265 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48266 wxButton *arg2 = (wxButton *) 0 ;
48267 void *argp1 = 0 ;
48268 int res1 = 0 ;
48269 void *argp2 = 0 ;
48270 int res2 = 0 ;
48271 PyObject * obj0 = 0 ;
48272 PyObject * obj1 = 0 ;
48273 char * kwnames[] = {
48274 (char *) "self",(char *) "button", NULL
48275 };
48276
48277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48279 if (!SWIG_IsOK(res1)) {
48280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48281 }
48282 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48284 if (!SWIG_IsOK(res2)) {
48285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48286 }
48287 arg2 = reinterpret_cast< wxButton * >(argp2);
48288 {
48289 PyThreadState* __tstate = wxPyBeginAllowThreads();
48290 (arg1)->SetCancelButton(arg2);
48291 wxPyEndAllowThreads(__tstate);
48292 if (PyErr_Occurred()) SWIG_fail;
48293 }
48294 resultobj = SWIG_Py_Void();
48295 return resultobj;
48296 fail:
48297 return NULL;
48298 }
48299
48300
48301 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48302 PyObject *resultobj = 0;
48303 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48304 wxButton *result = 0 ;
48305 void *argp1 = 0 ;
48306 int res1 = 0 ;
48307 PyObject *swig_obj[1] ;
48308
48309 if (!args) SWIG_fail;
48310 swig_obj[0] = args;
48311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48312 if (!SWIG_IsOK(res1)) {
48313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48314 }
48315 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48316 {
48317 PyThreadState* __tstate = wxPyBeginAllowThreads();
48318 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48319 wxPyEndAllowThreads(__tstate);
48320 if (PyErr_Occurred()) SWIG_fail;
48321 }
48322 {
48323 resultobj = wxPyMake_wxObject(result, (bool)0);
48324 }
48325 return resultobj;
48326 fail:
48327 return NULL;
48328 }
48329
48330
48331 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48332 PyObject *resultobj = 0;
48333 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48334 wxButton *result = 0 ;
48335 void *argp1 = 0 ;
48336 int res1 = 0 ;
48337 PyObject *swig_obj[1] ;
48338
48339 if (!args) SWIG_fail;
48340 swig_obj[0] = args;
48341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48342 if (!SWIG_IsOK(res1)) {
48343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48344 }
48345 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48346 {
48347 PyThreadState* __tstate = wxPyBeginAllowThreads();
48348 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48349 wxPyEndAllowThreads(__tstate);
48350 if (PyErr_Occurred()) SWIG_fail;
48351 }
48352 {
48353 resultobj = wxPyMake_wxObject(result, (bool)0);
48354 }
48355 return resultobj;
48356 fail:
48357 return NULL;
48358 }
48359
48360
48361 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48362 PyObject *resultobj = 0;
48363 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48364 wxButton *result = 0 ;
48365 void *argp1 = 0 ;
48366 int res1 = 0 ;
48367 PyObject *swig_obj[1] ;
48368
48369 if (!args) SWIG_fail;
48370 swig_obj[0] = args;
48371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48372 if (!SWIG_IsOK(res1)) {
48373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48374 }
48375 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48376 {
48377 PyThreadState* __tstate = wxPyBeginAllowThreads();
48378 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48379 wxPyEndAllowThreads(__tstate);
48380 if (PyErr_Occurred()) SWIG_fail;
48381 }
48382 {
48383 resultobj = wxPyMake_wxObject(result, (bool)0);
48384 }
48385 return resultobj;
48386 fail:
48387 return NULL;
48388 }
48389
48390
48391 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48392 PyObject *resultobj = 0;
48393 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48394 wxButton *result = 0 ;
48395 void *argp1 = 0 ;
48396 int res1 = 0 ;
48397 PyObject *swig_obj[1] ;
48398
48399 if (!args) SWIG_fail;
48400 swig_obj[0] = args;
48401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48402 if (!SWIG_IsOK(res1)) {
48403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48404 }
48405 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48406 {
48407 PyThreadState* __tstate = wxPyBeginAllowThreads();
48408 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48409 wxPyEndAllowThreads(__tstate);
48410 if (PyErr_Occurred()) SWIG_fail;
48411 }
48412 {
48413 resultobj = wxPyMake_wxObject(result, (bool)0);
48414 }
48415 return resultobj;
48416 fail:
48417 return NULL;
48418 }
48419
48420
48421 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48422 PyObject *resultobj = 0;
48423 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48424 wxButton *result = 0 ;
48425 void *argp1 = 0 ;
48426 int res1 = 0 ;
48427 PyObject *swig_obj[1] ;
48428
48429 if (!args) SWIG_fail;
48430 swig_obj[0] = args;
48431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48432 if (!SWIG_IsOK(res1)) {
48433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48434 }
48435 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48436 {
48437 PyThreadState* __tstate = wxPyBeginAllowThreads();
48438 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48439 wxPyEndAllowThreads(__tstate);
48440 if (PyErr_Occurred()) SWIG_fail;
48441 }
48442 {
48443 resultobj = wxPyMake_wxObject(result, (bool)0);
48444 }
48445 return resultobj;
48446 fail:
48447 return NULL;
48448 }
48449
48450
48451 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48452 PyObject *obj;
48453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48454 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48455 return SWIG_Py_Void();
48456 }
48457
48458 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48459 return SWIG_Python_InitShadowInstance(args);
48460 }
48461
48462 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48463 PyObject *resultobj = 0;
48464 int arg1 = (int) 0 ;
48465 int arg2 = (int) 0 ;
48466 wxGBPosition *result = 0 ;
48467 int val1 ;
48468 int ecode1 = 0 ;
48469 int val2 ;
48470 int ecode2 = 0 ;
48471 PyObject * obj0 = 0 ;
48472 PyObject * obj1 = 0 ;
48473 char * kwnames[] = {
48474 (char *) "row",(char *) "col", NULL
48475 };
48476
48477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48478 if (obj0) {
48479 ecode1 = SWIG_AsVal_int(obj0, &val1);
48480 if (!SWIG_IsOK(ecode1)) {
48481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48482 }
48483 arg1 = static_cast< int >(val1);
48484 }
48485 if (obj1) {
48486 ecode2 = SWIG_AsVal_int(obj1, &val2);
48487 if (!SWIG_IsOK(ecode2)) {
48488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48489 }
48490 arg2 = static_cast< int >(val2);
48491 }
48492 {
48493 PyThreadState* __tstate = wxPyBeginAllowThreads();
48494 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48495 wxPyEndAllowThreads(__tstate);
48496 if (PyErr_Occurred()) SWIG_fail;
48497 }
48498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48499 return resultobj;
48500 fail:
48501 return NULL;
48502 }
48503
48504
48505 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48506 PyObject *resultobj = 0;
48507 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48508 void *argp1 = 0 ;
48509 int res1 = 0 ;
48510 PyObject *swig_obj[1] ;
48511
48512 if (!args) SWIG_fail;
48513 swig_obj[0] = args;
48514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48515 if (!SWIG_IsOK(res1)) {
48516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48517 }
48518 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48519 {
48520 PyThreadState* __tstate = wxPyBeginAllowThreads();
48521 delete arg1;
48522
48523 wxPyEndAllowThreads(__tstate);
48524 if (PyErr_Occurred()) SWIG_fail;
48525 }
48526 resultobj = SWIG_Py_Void();
48527 return resultobj;
48528 fail:
48529 return NULL;
48530 }
48531
48532
48533 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48534 PyObject *resultobj = 0;
48535 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48536 int result;
48537 void *argp1 = 0 ;
48538 int res1 = 0 ;
48539 PyObject *swig_obj[1] ;
48540
48541 if (!args) SWIG_fail;
48542 swig_obj[0] = args;
48543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48544 if (!SWIG_IsOK(res1)) {
48545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48546 }
48547 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48548 {
48549 PyThreadState* __tstate = wxPyBeginAllowThreads();
48550 result = (int)((wxGBPosition const *)arg1)->GetRow();
48551 wxPyEndAllowThreads(__tstate);
48552 if (PyErr_Occurred()) SWIG_fail;
48553 }
48554 resultobj = SWIG_From_int(static_cast< int >(result));
48555 return resultobj;
48556 fail:
48557 return NULL;
48558 }
48559
48560
48561 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48562 PyObject *resultobj = 0;
48563 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48564 int result;
48565 void *argp1 = 0 ;
48566 int res1 = 0 ;
48567 PyObject *swig_obj[1] ;
48568
48569 if (!args) SWIG_fail;
48570 swig_obj[0] = args;
48571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48572 if (!SWIG_IsOK(res1)) {
48573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48574 }
48575 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48576 {
48577 PyThreadState* __tstate = wxPyBeginAllowThreads();
48578 result = (int)((wxGBPosition const *)arg1)->GetCol();
48579 wxPyEndAllowThreads(__tstate);
48580 if (PyErr_Occurred()) SWIG_fail;
48581 }
48582 resultobj = SWIG_From_int(static_cast< int >(result));
48583 return resultobj;
48584 fail:
48585 return NULL;
48586 }
48587
48588
48589 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48590 PyObject *resultobj = 0;
48591 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48592 int arg2 ;
48593 void *argp1 = 0 ;
48594 int res1 = 0 ;
48595 int val2 ;
48596 int ecode2 = 0 ;
48597 PyObject * obj0 = 0 ;
48598 PyObject * obj1 = 0 ;
48599 char * kwnames[] = {
48600 (char *) "self",(char *) "row", NULL
48601 };
48602
48603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48605 if (!SWIG_IsOK(res1)) {
48606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48607 }
48608 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48609 ecode2 = SWIG_AsVal_int(obj1, &val2);
48610 if (!SWIG_IsOK(ecode2)) {
48611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48612 }
48613 arg2 = static_cast< int >(val2);
48614 {
48615 PyThreadState* __tstate = wxPyBeginAllowThreads();
48616 (arg1)->SetRow(arg2);
48617 wxPyEndAllowThreads(__tstate);
48618 if (PyErr_Occurred()) SWIG_fail;
48619 }
48620 resultobj = SWIG_Py_Void();
48621 return resultobj;
48622 fail:
48623 return NULL;
48624 }
48625
48626
48627 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48628 PyObject *resultobj = 0;
48629 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48630 int arg2 ;
48631 void *argp1 = 0 ;
48632 int res1 = 0 ;
48633 int val2 ;
48634 int ecode2 = 0 ;
48635 PyObject * obj0 = 0 ;
48636 PyObject * obj1 = 0 ;
48637 char * kwnames[] = {
48638 (char *) "self",(char *) "col", NULL
48639 };
48640
48641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48643 if (!SWIG_IsOK(res1)) {
48644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48645 }
48646 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48647 ecode2 = SWIG_AsVal_int(obj1, &val2);
48648 if (!SWIG_IsOK(ecode2)) {
48649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48650 }
48651 arg2 = static_cast< int >(val2);
48652 {
48653 PyThreadState* __tstate = wxPyBeginAllowThreads();
48654 (arg1)->SetCol(arg2);
48655 wxPyEndAllowThreads(__tstate);
48656 if (PyErr_Occurred()) SWIG_fail;
48657 }
48658 resultobj = SWIG_Py_Void();
48659 return resultobj;
48660 fail:
48661 return NULL;
48662 }
48663
48664
48665 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48666 PyObject *resultobj = 0;
48667 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48668 wxGBPosition *arg2 = 0 ;
48669 bool result;
48670 void *argp1 = 0 ;
48671 int res1 = 0 ;
48672 wxGBPosition temp2 ;
48673 PyObject * obj0 = 0 ;
48674 PyObject * obj1 = 0 ;
48675 char * kwnames[] = {
48676 (char *) "self",(char *) "other", NULL
48677 };
48678
48679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48681 if (!SWIG_IsOK(res1)) {
48682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48683 }
48684 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48685 {
48686 arg2 = &temp2;
48687 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48688 }
48689 {
48690 PyThreadState* __tstate = wxPyBeginAllowThreads();
48691 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
48692 wxPyEndAllowThreads(__tstate);
48693 if (PyErr_Occurred()) SWIG_fail;
48694 }
48695 {
48696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48697 }
48698 return resultobj;
48699 fail:
48700 return NULL;
48701 }
48702
48703
48704 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48705 PyObject *resultobj = 0;
48706 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48707 wxGBPosition *arg2 = 0 ;
48708 bool result;
48709 void *argp1 = 0 ;
48710 int res1 = 0 ;
48711 wxGBPosition temp2 ;
48712 PyObject * obj0 = 0 ;
48713 PyObject * obj1 = 0 ;
48714 char * kwnames[] = {
48715 (char *) "self",(char *) "other", NULL
48716 };
48717
48718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48720 if (!SWIG_IsOK(res1)) {
48721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48722 }
48723 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48724 {
48725 arg2 = &temp2;
48726 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48727 }
48728 {
48729 PyThreadState* __tstate = wxPyBeginAllowThreads();
48730 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
48731 wxPyEndAllowThreads(__tstate);
48732 if (PyErr_Occurred()) SWIG_fail;
48733 }
48734 {
48735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48736 }
48737 return resultobj;
48738 fail:
48739 return NULL;
48740 }
48741
48742
48743 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48744 PyObject *resultobj = 0;
48745 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48746 int arg2 = (int) 0 ;
48747 int arg3 = (int) 0 ;
48748 void *argp1 = 0 ;
48749 int res1 = 0 ;
48750 int val2 ;
48751 int ecode2 = 0 ;
48752 int val3 ;
48753 int ecode3 = 0 ;
48754 PyObject * obj0 = 0 ;
48755 PyObject * obj1 = 0 ;
48756 PyObject * obj2 = 0 ;
48757 char * kwnames[] = {
48758 (char *) "self",(char *) "row",(char *) "col", NULL
48759 };
48760
48761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48763 if (!SWIG_IsOK(res1)) {
48764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48765 }
48766 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48767 if (obj1) {
48768 ecode2 = SWIG_AsVal_int(obj1, &val2);
48769 if (!SWIG_IsOK(ecode2)) {
48770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48771 }
48772 arg2 = static_cast< int >(val2);
48773 }
48774 if (obj2) {
48775 ecode3 = SWIG_AsVal_int(obj2, &val3);
48776 if (!SWIG_IsOK(ecode3)) {
48777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48778 }
48779 arg3 = static_cast< int >(val3);
48780 }
48781 {
48782 PyThreadState* __tstate = wxPyBeginAllowThreads();
48783 wxGBPosition_Set(arg1,arg2,arg3);
48784 wxPyEndAllowThreads(__tstate);
48785 if (PyErr_Occurred()) SWIG_fail;
48786 }
48787 resultobj = SWIG_Py_Void();
48788 return resultobj;
48789 fail:
48790 return NULL;
48791 }
48792
48793
48794 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48795 PyObject *resultobj = 0;
48796 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48797 PyObject *result = 0 ;
48798 void *argp1 = 0 ;
48799 int res1 = 0 ;
48800 PyObject *swig_obj[1] ;
48801
48802 if (!args) SWIG_fail;
48803 swig_obj[0] = args;
48804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48805 if (!SWIG_IsOK(res1)) {
48806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48807 }
48808 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48809 {
48810 PyThreadState* __tstate = wxPyBeginAllowThreads();
48811 result = (PyObject *)wxGBPosition_Get(arg1);
48812 wxPyEndAllowThreads(__tstate);
48813 if (PyErr_Occurred()) SWIG_fail;
48814 }
48815 resultobj = result;
48816 return resultobj;
48817 fail:
48818 return NULL;
48819 }
48820
48821
48822 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48823 PyObject *obj;
48824 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48825 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48826 return SWIG_Py_Void();
48827 }
48828
48829 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48830 return SWIG_Python_InitShadowInstance(args);
48831 }
48832
48833 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48834 PyObject *resultobj = 0;
48835 int arg1 = (int) 1 ;
48836 int arg2 = (int) 1 ;
48837 wxGBSpan *result = 0 ;
48838 int val1 ;
48839 int ecode1 = 0 ;
48840 int val2 ;
48841 int ecode2 = 0 ;
48842 PyObject * obj0 = 0 ;
48843 PyObject * obj1 = 0 ;
48844 char * kwnames[] = {
48845 (char *) "rowspan",(char *) "colspan", NULL
48846 };
48847
48848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48849 if (obj0) {
48850 ecode1 = SWIG_AsVal_int(obj0, &val1);
48851 if (!SWIG_IsOK(ecode1)) {
48852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48853 }
48854 arg1 = static_cast< int >(val1);
48855 }
48856 if (obj1) {
48857 ecode2 = SWIG_AsVal_int(obj1, &val2);
48858 if (!SWIG_IsOK(ecode2)) {
48859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48860 }
48861 arg2 = static_cast< int >(val2);
48862 }
48863 {
48864 PyThreadState* __tstate = wxPyBeginAllowThreads();
48865 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48866 wxPyEndAllowThreads(__tstate);
48867 if (PyErr_Occurred()) SWIG_fail;
48868 }
48869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
48870 return resultobj;
48871 fail:
48872 return NULL;
48873 }
48874
48875
48876 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48877 PyObject *resultobj = 0;
48878 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48879 void *argp1 = 0 ;
48880 int res1 = 0 ;
48881 PyObject *swig_obj[1] ;
48882
48883 if (!args) SWIG_fail;
48884 swig_obj[0] = args;
48885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
48886 if (!SWIG_IsOK(res1)) {
48887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48888 }
48889 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48890 {
48891 PyThreadState* __tstate = wxPyBeginAllowThreads();
48892 delete arg1;
48893
48894 wxPyEndAllowThreads(__tstate);
48895 if (PyErr_Occurred()) SWIG_fail;
48896 }
48897 resultobj = SWIG_Py_Void();
48898 return resultobj;
48899 fail:
48900 return NULL;
48901 }
48902
48903
48904 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48905 PyObject *resultobj = 0;
48906 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48907 int result;
48908 void *argp1 = 0 ;
48909 int res1 = 0 ;
48910 PyObject *swig_obj[1] ;
48911
48912 if (!args) SWIG_fail;
48913 swig_obj[0] = args;
48914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48915 if (!SWIG_IsOK(res1)) {
48916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48917 }
48918 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48919 {
48920 PyThreadState* __tstate = wxPyBeginAllowThreads();
48921 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
48922 wxPyEndAllowThreads(__tstate);
48923 if (PyErr_Occurred()) SWIG_fail;
48924 }
48925 resultobj = SWIG_From_int(static_cast< int >(result));
48926 return resultobj;
48927 fail:
48928 return NULL;
48929 }
48930
48931
48932 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48933 PyObject *resultobj = 0;
48934 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48935 int result;
48936 void *argp1 = 0 ;
48937 int res1 = 0 ;
48938 PyObject *swig_obj[1] ;
48939
48940 if (!args) SWIG_fail;
48941 swig_obj[0] = args;
48942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48943 if (!SWIG_IsOK(res1)) {
48944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48945 }
48946 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48947 {
48948 PyThreadState* __tstate = wxPyBeginAllowThreads();
48949 result = (int)((wxGBSpan const *)arg1)->GetColspan();
48950 wxPyEndAllowThreads(__tstate);
48951 if (PyErr_Occurred()) SWIG_fail;
48952 }
48953 resultobj = SWIG_From_int(static_cast< int >(result));
48954 return resultobj;
48955 fail:
48956 return NULL;
48957 }
48958
48959
48960 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48961 PyObject *resultobj = 0;
48962 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48963 int arg2 ;
48964 void *argp1 = 0 ;
48965 int res1 = 0 ;
48966 int val2 ;
48967 int ecode2 = 0 ;
48968 PyObject * obj0 = 0 ;
48969 PyObject * obj1 = 0 ;
48970 char * kwnames[] = {
48971 (char *) "self",(char *) "rowspan", NULL
48972 };
48973
48974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
48975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48976 if (!SWIG_IsOK(res1)) {
48977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48978 }
48979 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48980 ecode2 = SWIG_AsVal_int(obj1, &val2);
48981 if (!SWIG_IsOK(ecode2)) {
48982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
48983 }
48984 arg2 = static_cast< int >(val2);
48985 {
48986 PyThreadState* __tstate = wxPyBeginAllowThreads();
48987 (arg1)->SetRowspan(arg2);
48988 wxPyEndAllowThreads(__tstate);
48989 if (PyErr_Occurred()) SWIG_fail;
48990 }
48991 resultobj = SWIG_Py_Void();
48992 return resultobj;
48993 fail:
48994 return NULL;
48995 }
48996
48997
48998 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48999 PyObject *resultobj = 0;
49000 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49001 int arg2 ;
49002 void *argp1 = 0 ;
49003 int res1 = 0 ;
49004 int val2 ;
49005 int ecode2 = 0 ;
49006 PyObject * obj0 = 0 ;
49007 PyObject * obj1 = 0 ;
49008 char * kwnames[] = {
49009 (char *) "self",(char *) "colspan", NULL
49010 };
49011
49012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49014 if (!SWIG_IsOK(res1)) {
49015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49016 }
49017 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49018 ecode2 = SWIG_AsVal_int(obj1, &val2);
49019 if (!SWIG_IsOK(ecode2)) {
49020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49021 }
49022 arg2 = static_cast< int >(val2);
49023 {
49024 PyThreadState* __tstate = wxPyBeginAllowThreads();
49025 (arg1)->SetColspan(arg2);
49026 wxPyEndAllowThreads(__tstate);
49027 if (PyErr_Occurred()) SWIG_fail;
49028 }
49029 resultobj = SWIG_Py_Void();
49030 return resultobj;
49031 fail:
49032 return NULL;
49033 }
49034
49035
49036 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49037 PyObject *resultobj = 0;
49038 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49039 wxGBSpan *arg2 = 0 ;
49040 bool result;
49041 void *argp1 = 0 ;
49042 int res1 = 0 ;
49043 wxGBSpan temp2 ;
49044 PyObject * obj0 = 0 ;
49045 PyObject * obj1 = 0 ;
49046 char * kwnames[] = {
49047 (char *) "self",(char *) "other", NULL
49048 };
49049
49050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49052 if (!SWIG_IsOK(res1)) {
49053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49054 }
49055 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49056 {
49057 arg2 = &temp2;
49058 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49059 }
49060 {
49061 PyThreadState* __tstate = wxPyBeginAllowThreads();
49062 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
49063 wxPyEndAllowThreads(__tstate);
49064 if (PyErr_Occurred()) SWIG_fail;
49065 }
49066 {
49067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49068 }
49069 return resultobj;
49070 fail:
49071 return NULL;
49072 }
49073
49074
49075 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49076 PyObject *resultobj = 0;
49077 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49078 wxGBSpan *arg2 = 0 ;
49079 bool result;
49080 void *argp1 = 0 ;
49081 int res1 = 0 ;
49082 wxGBSpan temp2 ;
49083 PyObject * obj0 = 0 ;
49084 PyObject * obj1 = 0 ;
49085 char * kwnames[] = {
49086 (char *) "self",(char *) "other", NULL
49087 };
49088
49089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49091 if (!SWIG_IsOK(res1)) {
49092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49093 }
49094 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49095 {
49096 arg2 = &temp2;
49097 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49098 }
49099 {
49100 PyThreadState* __tstate = wxPyBeginAllowThreads();
49101 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
49102 wxPyEndAllowThreads(__tstate);
49103 if (PyErr_Occurred()) SWIG_fail;
49104 }
49105 {
49106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49107 }
49108 return resultobj;
49109 fail:
49110 return NULL;
49111 }
49112
49113
49114 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49115 PyObject *resultobj = 0;
49116 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49117 int arg2 = (int) 1 ;
49118 int arg3 = (int) 1 ;
49119 void *argp1 = 0 ;
49120 int res1 = 0 ;
49121 int val2 ;
49122 int ecode2 = 0 ;
49123 int val3 ;
49124 int ecode3 = 0 ;
49125 PyObject * obj0 = 0 ;
49126 PyObject * obj1 = 0 ;
49127 PyObject * obj2 = 0 ;
49128 char * kwnames[] = {
49129 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49130 };
49131
49132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49134 if (!SWIG_IsOK(res1)) {
49135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49136 }
49137 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49138 if (obj1) {
49139 ecode2 = SWIG_AsVal_int(obj1, &val2);
49140 if (!SWIG_IsOK(ecode2)) {
49141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49142 }
49143 arg2 = static_cast< int >(val2);
49144 }
49145 if (obj2) {
49146 ecode3 = SWIG_AsVal_int(obj2, &val3);
49147 if (!SWIG_IsOK(ecode3)) {
49148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49149 }
49150 arg3 = static_cast< int >(val3);
49151 }
49152 {
49153 PyThreadState* __tstate = wxPyBeginAllowThreads();
49154 wxGBSpan_Set(arg1,arg2,arg3);
49155 wxPyEndAllowThreads(__tstate);
49156 if (PyErr_Occurred()) SWIG_fail;
49157 }
49158 resultobj = SWIG_Py_Void();
49159 return resultobj;
49160 fail:
49161 return NULL;
49162 }
49163
49164
49165 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49166 PyObject *resultobj = 0;
49167 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49168 PyObject *result = 0 ;
49169 void *argp1 = 0 ;
49170 int res1 = 0 ;
49171 PyObject *swig_obj[1] ;
49172
49173 if (!args) SWIG_fail;
49174 swig_obj[0] = args;
49175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49176 if (!SWIG_IsOK(res1)) {
49177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49178 }
49179 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49180 {
49181 PyThreadState* __tstate = wxPyBeginAllowThreads();
49182 result = (PyObject *)wxGBSpan_Get(arg1);
49183 wxPyEndAllowThreads(__tstate);
49184 if (PyErr_Occurred()) SWIG_fail;
49185 }
49186 resultobj = result;
49187 return resultobj;
49188 fail:
49189 return NULL;
49190 }
49191
49192
49193 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49194 PyObject *obj;
49195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49196 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49197 return SWIG_Py_Void();
49198 }
49199
49200 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49201 return SWIG_Python_InitShadowInstance(args);
49202 }
49203
49204 SWIGINTERN int DefaultSpan_set(PyObject *) {
49205 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49206 return 1;
49207 }
49208
49209
49210 SWIGINTERN PyObject *DefaultSpan_get(void) {
49211 PyObject *pyobj = 0;
49212
49213 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49214 return pyobj;
49215 }
49216
49217
49218 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49219 PyObject *resultobj = 0;
49220 wxGBSizerItem *result = 0 ;
49221
49222 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49223 {
49224 PyThreadState* __tstate = wxPyBeginAllowThreads();
49225 result = (wxGBSizerItem *)new wxGBSizerItem();
49226 wxPyEndAllowThreads(__tstate);
49227 if (PyErr_Occurred()) SWIG_fail;
49228 }
49229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49230 return resultobj;
49231 fail:
49232 return NULL;
49233 }
49234
49235
49236 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49237 PyObject *resultobj = 0;
49238 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49239 void *argp1 = 0 ;
49240 int res1 = 0 ;
49241 PyObject *swig_obj[1] ;
49242
49243 if (!args) SWIG_fail;
49244 swig_obj[0] = args;
49245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49246 if (!SWIG_IsOK(res1)) {
49247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49248 }
49249 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49250 {
49251 PyThreadState* __tstate = wxPyBeginAllowThreads();
49252 delete arg1;
49253
49254 wxPyEndAllowThreads(__tstate);
49255 if (PyErr_Occurred()) SWIG_fail;
49256 }
49257 resultobj = SWIG_Py_Void();
49258 return resultobj;
49259 fail:
49260 return NULL;
49261 }
49262
49263
49264 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49265 PyObject *resultobj = 0;
49266 wxWindow *arg1 = (wxWindow *) 0 ;
49267 wxGBPosition *arg2 = 0 ;
49268 wxGBSpan *arg3 = 0 ;
49269 int arg4 ;
49270 int arg5 ;
49271 PyObject *arg6 = (PyObject *) NULL ;
49272 wxGBSizerItem *result = 0 ;
49273 void *argp1 = 0 ;
49274 int res1 = 0 ;
49275 wxGBPosition temp2 ;
49276 wxGBSpan temp3 ;
49277 int val4 ;
49278 int ecode4 = 0 ;
49279 int val5 ;
49280 int ecode5 = 0 ;
49281 PyObject * obj0 = 0 ;
49282 PyObject * obj1 = 0 ;
49283 PyObject * obj2 = 0 ;
49284 PyObject * obj3 = 0 ;
49285 PyObject * obj4 = 0 ;
49286 PyObject * obj5 = 0 ;
49287 char * kwnames[] = {
49288 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49289 };
49290
49291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49293 if (!SWIG_IsOK(res1)) {
49294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49295 }
49296 arg1 = reinterpret_cast< wxWindow * >(argp1);
49297 {
49298 arg2 = &temp2;
49299 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49300 }
49301 {
49302 arg3 = &temp3;
49303 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49304 }
49305 ecode4 = SWIG_AsVal_int(obj3, &val4);
49306 if (!SWIG_IsOK(ecode4)) {
49307 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49308 }
49309 arg4 = static_cast< int >(val4);
49310 ecode5 = SWIG_AsVal_int(obj4, &val5);
49311 if (!SWIG_IsOK(ecode5)) {
49312 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49313 }
49314 arg5 = static_cast< int >(val5);
49315 if (obj5) {
49316 arg6 = obj5;
49317 }
49318 {
49319 PyThreadState* __tstate = wxPyBeginAllowThreads();
49320 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49321 wxPyEndAllowThreads(__tstate);
49322 if (PyErr_Occurred()) SWIG_fail;
49323 }
49324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49325 return resultobj;
49326 fail:
49327 return NULL;
49328 }
49329
49330
49331 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49332 PyObject *resultobj = 0;
49333 wxSizer *arg1 = (wxSizer *) 0 ;
49334 wxGBPosition *arg2 = 0 ;
49335 wxGBSpan *arg3 = 0 ;
49336 int arg4 ;
49337 int arg5 ;
49338 PyObject *arg6 = (PyObject *) NULL ;
49339 wxGBSizerItem *result = 0 ;
49340 int res1 = 0 ;
49341 wxGBPosition temp2 ;
49342 wxGBSpan temp3 ;
49343 int val4 ;
49344 int ecode4 = 0 ;
49345 int val5 ;
49346 int ecode5 = 0 ;
49347 PyObject * obj0 = 0 ;
49348 PyObject * obj1 = 0 ;
49349 PyObject * obj2 = 0 ;
49350 PyObject * obj3 = 0 ;
49351 PyObject * obj4 = 0 ;
49352 PyObject * obj5 = 0 ;
49353 char * kwnames[] = {
49354 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49355 };
49356
49357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49358 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49359 if (!SWIG_IsOK(res1)) {
49360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49361 }
49362 {
49363 arg2 = &temp2;
49364 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49365 }
49366 {
49367 arg3 = &temp3;
49368 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49369 }
49370 ecode4 = SWIG_AsVal_int(obj3, &val4);
49371 if (!SWIG_IsOK(ecode4)) {
49372 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49373 }
49374 arg4 = static_cast< int >(val4);
49375 ecode5 = SWIG_AsVal_int(obj4, &val5);
49376 if (!SWIG_IsOK(ecode5)) {
49377 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49378 }
49379 arg5 = static_cast< int >(val5);
49380 if (obj5) {
49381 arg6 = obj5;
49382 }
49383 {
49384 PyThreadState* __tstate = wxPyBeginAllowThreads();
49385 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49386 wxPyEndAllowThreads(__tstate);
49387 if (PyErr_Occurred()) SWIG_fail;
49388 }
49389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49390 return resultobj;
49391 fail:
49392 return NULL;
49393 }
49394
49395
49396 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49397 PyObject *resultobj = 0;
49398 int arg1 ;
49399 int arg2 ;
49400 wxGBPosition *arg3 = 0 ;
49401 wxGBSpan *arg4 = 0 ;
49402 int arg5 ;
49403 int arg6 ;
49404 PyObject *arg7 = (PyObject *) NULL ;
49405 wxGBSizerItem *result = 0 ;
49406 int val1 ;
49407 int ecode1 = 0 ;
49408 int val2 ;
49409 int ecode2 = 0 ;
49410 wxGBPosition temp3 ;
49411 wxGBSpan temp4 ;
49412 int val5 ;
49413 int ecode5 = 0 ;
49414 int val6 ;
49415 int ecode6 = 0 ;
49416 PyObject * obj0 = 0 ;
49417 PyObject * obj1 = 0 ;
49418 PyObject * obj2 = 0 ;
49419 PyObject * obj3 = 0 ;
49420 PyObject * obj4 = 0 ;
49421 PyObject * obj5 = 0 ;
49422 PyObject * obj6 = 0 ;
49423 char * kwnames[] = {
49424 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49425 };
49426
49427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49428 ecode1 = SWIG_AsVal_int(obj0, &val1);
49429 if (!SWIG_IsOK(ecode1)) {
49430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49431 }
49432 arg1 = static_cast< int >(val1);
49433 ecode2 = SWIG_AsVal_int(obj1, &val2);
49434 if (!SWIG_IsOK(ecode2)) {
49435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49436 }
49437 arg2 = static_cast< int >(val2);
49438 {
49439 arg3 = &temp3;
49440 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49441 }
49442 {
49443 arg4 = &temp4;
49444 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49445 }
49446 ecode5 = SWIG_AsVal_int(obj4, &val5);
49447 if (!SWIG_IsOK(ecode5)) {
49448 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49449 }
49450 arg5 = static_cast< int >(val5);
49451 ecode6 = SWIG_AsVal_int(obj5, &val6);
49452 if (!SWIG_IsOK(ecode6)) {
49453 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49454 }
49455 arg6 = static_cast< int >(val6);
49456 if (obj6) {
49457 arg7 = obj6;
49458 }
49459 {
49460 PyThreadState* __tstate = wxPyBeginAllowThreads();
49461 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49462 wxPyEndAllowThreads(__tstate);
49463 if (PyErr_Occurred()) SWIG_fail;
49464 }
49465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49466 return resultobj;
49467 fail:
49468 return NULL;
49469 }
49470
49471
49472 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49473 PyObject *resultobj = 0;
49474 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49475 wxGBPosition result;
49476 void *argp1 = 0 ;
49477 int res1 = 0 ;
49478 PyObject *swig_obj[1] ;
49479
49480 if (!args) SWIG_fail;
49481 swig_obj[0] = args;
49482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49483 if (!SWIG_IsOK(res1)) {
49484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49485 }
49486 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49487 {
49488 PyThreadState* __tstate = wxPyBeginAllowThreads();
49489 result = ((wxGBSizerItem const *)arg1)->GetPos();
49490 wxPyEndAllowThreads(__tstate);
49491 if (PyErr_Occurred()) SWIG_fail;
49492 }
49493 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49494 return resultobj;
49495 fail:
49496 return NULL;
49497 }
49498
49499
49500 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49501 PyObject *resultobj = 0;
49502 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49503 wxGBSpan result;
49504 void *argp1 = 0 ;
49505 int res1 = 0 ;
49506 PyObject *swig_obj[1] ;
49507
49508 if (!args) SWIG_fail;
49509 swig_obj[0] = args;
49510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49511 if (!SWIG_IsOK(res1)) {
49512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49513 }
49514 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49515 {
49516 PyThreadState* __tstate = wxPyBeginAllowThreads();
49517 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49518 wxPyEndAllowThreads(__tstate);
49519 if (PyErr_Occurred()) SWIG_fail;
49520 }
49521 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49522 return resultobj;
49523 fail:
49524 return NULL;
49525 }
49526
49527
49528 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49529 PyObject *resultobj = 0;
49530 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49531 wxGBPosition *arg2 = 0 ;
49532 bool result;
49533 void *argp1 = 0 ;
49534 int res1 = 0 ;
49535 wxGBPosition temp2 ;
49536 PyObject * obj0 = 0 ;
49537 PyObject * obj1 = 0 ;
49538 char * kwnames[] = {
49539 (char *) "self",(char *) "pos", NULL
49540 };
49541
49542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49544 if (!SWIG_IsOK(res1)) {
49545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49546 }
49547 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49548 {
49549 arg2 = &temp2;
49550 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49551 }
49552 {
49553 PyThreadState* __tstate = wxPyBeginAllowThreads();
49554 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49555 wxPyEndAllowThreads(__tstate);
49556 if (PyErr_Occurred()) SWIG_fail;
49557 }
49558 {
49559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49560 }
49561 return resultobj;
49562 fail:
49563 return NULL;
49564 }
49565
49566
49567 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49568 PyObject *resultobj = 0;
49569 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49570 wxGBSpan *arg2 = 0 ;
49571 bool result;
49572 void *argp1 = 0 ;
49573 int res1 = 0 ;
49574 wxGBSpan temp2 ;
49575 PyObject * obj0 = 0 ;
49576 PyObject * obj1 = 0 ;
49577 char * kwnames[] = {
49578 (char *) "self",(char *) "span", NULL
49579 };
49580
49581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49583 if (!SWIG_IsOK(res1)) {
49584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49585 }
49586 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49587 {
49588 arg2 = &temp2;
49589 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49590 }
49591 {
49592 PyThreadState* __tstate = wxPyBeginAllowThreads();
49593 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49594 wxPyEndAllowThreads(__tstate);
49595 if (PyErr_Occurred()) SWIG_fail;
49596 }
49597 {
49598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49599 }
49600 return resultobj;
49601 fail:
49602 return NULL;
49603 }
49604
49605
49606 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49607 PyObject *resultobj = 0;
49608 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49609 wxGBSizerItem *arg2 = 0 ;
49610 bool result;
49611 void *argp1 = 0 ;
49612 int res1 = 0 ;
49613 void *argp2 = 0 ;
49614 int res2 = 0 ;
49615 PyObject * obj0 = 0 ;
49616 PyObject * obj1 = 0 ;
49617 char * kwnames[] = {
49618 (char *) "self",(char *) "other", NULL
49619 };
49620
49621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49623 if (!SWIG_IsOK(res1)) {
49624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49625 }
49626 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49627 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49628 if (!SWIG_IsOK(res2)) {
49629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49630 }
49631 if (!argp2) {
49632 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49633 }
49634 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49635 {
49636 PyThreadState* __tstate = wxPyBeginAllowThreads();
49637 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49638 wxPyEndAllowThreads(__tstate);
49639 if (PyErr_Occurred()) SWIG_fail;
49640 }
49641 {
49642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49643 }
49644 return resultobj;
49645 fail:
49646 return NULL;
49647 }
49648
49649
49650 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49651 PyObject *resultobj = 0;
49652 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49653 wxGBPosition *arg2 = 0 ;
49654 wxGBSpan *arg3 = 0 ;
49655 bool result;
49656 void *argp1 = 0 ;
49657 int res1 = 0 ;
49658 wxGBPosition temp2 ;
49659 wxGBSpan temp3 ;
49660 PyObject * obj0 = 0 ;
49661 PyObject * obj1 = 0 ;
49662 PyObject * obj2 = 0 ;
49663 char * kwnames[] = {
49664 (char *) "self",(char *) "pos",(char *) "span", NULL
49665 };
49666
49667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49669 if (!SWIG_IsOK(res1)) {
49670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49671 }
49672 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49673 {
49674 arg2 = &temp2;
49675 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49676 }
49677 {
49678 arg3 = &temp3;
49679 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49680 }
49681 {
49682 PyThreadState* __tstate = wxPyBeginAllowThreads();
49683 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49684 wxPyEndAllowThreads(__tstate);
49685 if (PyErr_Occurred()) SWIG_fail;
49686 }
49687 {
49688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49689 }
49690 return resultobj;
49691 fail:
49692 return NULL;
49693 }
49694
49695
49696 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49697 PyObject *resultobj = 0;
49698 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49699 wxGBPosition result;
49700 void *argp1 = 0 ;
49701 int res1 = 0 ;
49702 PyObject *swig_obj[1] ;
49703
49704 if (!args) SWIG_fail;
49705 swig_obj[0] = args;
49706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49707 if (!SWIG_IsOK(res1)) {
49708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49709 }
49710 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49711 {
49712 PyThreadState* __tstate = wxPyBeginAllowThreads();
49713 result = wxGBSizerItem_GetEndPos(arg1);
49714 wxPyEndAllowThreads(__tstate);
49715 if (PyErr_Occurred()) SWIG_fail;
49716 }
49717 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49718 return resultobj;
49719 fail:
49720 return NULL;
49721 }
49722
49723
49724 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49725 PyObject *resultobj = 0;
49726 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49727 wxGridBagSizer *result = 0 ;
49728 void *argp1 = 0 ;
49729 int res1 = 0 ;
49730 PyObject *swig_obj[1] ;
49731
49732 if (!args) SWIG_fail;
49733 swig_obj[0] = args;
49734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49735 if (!SWIG_IsOK(res1)) {
49736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49737 }
49738 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49739 {
49740 PyThreadState* __tstate = wxPyBeginAllowThreads();
49741 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49742 wxPyEndAllowThreads(__tstate);
49743 if (PyErr_Occurred()) SWIG_fail;
49744 }
49745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49746 return resultobj;
49747 fail:
49748 return NULL;
49749 }
49750
49751
49752 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49753 PyObject *resultobj = 0;
49754 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49755 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
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 *) "sizer", NULL
49764 };
49765
49766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",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_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49770 }
49771 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49772 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49773 if (!SWIG_IsOK(res2)) {
49774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49775 }
49776 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49777 {
49778 PyThreadState* __tstate = wxPyBeginAllowThreads();
49779 (arg1)->SetGBSizer(arg2);
49780 wxPyEndAllowThreads(__tstate);
49781 if (PyErr_Occurred()) SWIG_fail;
49782 }
49783 resultobj = SWIG_Py_Void();
49784 return resultobj;
49785 fail:
49786 return NULL;
49787 }
49788
49789
49790 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49791 PyObject *obj;
49792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49793 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49794 return SWIG_Py_Void();
49795 }
49796
49797 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49798 return SWIG_Python_InitShadowInstance(args);
49799 }
49800
49801 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49802 PyObject *resultobj = 0;
49803 int arg1 = (int) 0 ;
49804 int arg2 = (int) 0 ;
49805 wxGridBagSizer *result = 0 ;
49806 int val1 ;
49807 int ecode1 = 0 ;
49808 int val2 ;
49809 int ecode2 = 0 ;
49810 PyObject * obj0 = 0 ;
49811 PyObject * obj1 = 0 ;
49812 char * kwnames[] = {
49813 (char *) "vgap",(char *) "hgap", NULL
49814 };
49815
49816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49817 if (obj0) {
49818 ecode1 = SWIG_AsVal_int(obj0, &val1);
49819 if (!SWIG_IsOK(ecode1)) {
49820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49821 }
49822 arg1 = static_cast< int >(val1);
49823 }
49824 if (obj1) {
49825 ecode2 = SWIG_AsVal_int(obj1, &val2);
49826 if (!SWIG_IsOK(ecode2)) {
49827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49828 }
49829 arg2 = static_cast< int >(val2);
49830 }
49831 {
49832 PyThreadState* __tstate = wxPyBeginAllowThreads();
49833 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49834 wxPyEndAllowThreads(__tstate);
49835 if (PyErr_Occurred()) SWIG_fail;
49836 }
49837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49838 return resultobj;
49839 fail:
49840 return NULL;
49841 }
49842
49843
49844 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49845 PyObject *resultobj = 0;
49846 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49847 PyObject *arg2 = (PyObject *) 0 ;
49848 wxGBPosition *arg3 = 0 ;
49849 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49850 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49851 int arg5 = (int) 0 ;
49852 int arg6 = (int) 0 ;
49853 PyObject *arg7 = (PyObject *) NULL ;
49854 wxGBSizerItem *result = 0 ;
49855 void *argp1 = 0 ;
49856 int res1 = 0 ;
49857 wxGBPosition temp3 ;
49858 wxGBSpan temp4 ;
49859 int val5 ;
49860 int ecode5 = 0 ;
49861 int val6 ;
49862 int ecode6 = 0 ;
49863 PyObject * obj0 = 0 ;
49864 PyObject * obj1 = 0 ;
49865 PyObject * obj2 = 0 ;
49866 PyObject * obj3 = 0 ;
49867 PyObject * obj4 = 0 ;
49868 PyObject * obj5 = 0 ;
49869 PyObject * obj6 = 0 ;
49870 char * kwnames[] = {
49871 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49872 };
49873
49874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49876 if (!SWIG_IsOK(res1)) {
49877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49878 }
49879 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49880 arg2 = obj1;
49881 {
49882 arg3 = &temp3;
49883 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49884 }
49885 if (obj3) {
49886 {
49887 arg4 = &temp4;
49888 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49889 }
49890 }
49891 if (obj4) {
49892 ecode5 = SWIG_AsVal_int(obj4, &val5);
49893 if (!SWIG_IsOK(ecode5)) {
49894 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
49895 }
49896 arg5 = static_cast< int >(val5);
49897 }
49898 if (obj5) {
49899 ecode6 = SWIG_AsVal_int(obj5, &val6);
49900 if (!SWIG_IsOK(ecode6)) {
49901 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
49902 }
49903 arg6 = static_cast< int >(val6);
49904 }
49905 if (obj6) {
49906 arg7 = obj6;
49907 }
49908 {
49909 PyThreadState* __tstate = wxPyBeginAllowThreads();
49910 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49911 wxPyEndAllowThreads(__tstate);
49912 if (PyErr_Occurred()) SWIG_fail;
49913 }
49914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49915 return resultobj;
49916 fail:
49917 return NULL;
49918 }
49919
49920
49921 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49922 PyObject *resultobj = 0;
49923 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49924 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
49925 wxGBSizerItem *result = 0 ;
49926 void *argp1 = 0 ;
49927 int res1 = 0 ;
49928 int res2 = 0 ;
49929 PyObject * obj0 = 0 ;
49930 PyObject * obj1 = 0 ;
49931 char * kwnames[] = {
49932 (char *) "self",(char *) "item", NULL
49933 };
49934
49935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
49936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49937 if (!SWIG_IsOK(res1)) {
49938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49939 }
49940 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49941 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49942 if (!SWIG_IsOK(res2)) {
49943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
49944 }
49945 {
49946 PyThreadState* __tstate = wxPyBeginAllowThreads();
49947 result = (wxGBSizerItem *)(arg1)->Add(arg2);
49948 wxPyEndAllowThreads(__tstate);
49949 if (PyErr_Occurred()) SWIG_fail;
49950 }
49951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49952 return resultobj;
49953 fail:
49954 return NULL;
49955 }
49956
49957
49958 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49959 PyObject *resultobj = 0;
49960 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49961 int arg2 ;
49962 int arg3 ;
49963 wxSize result;
49964 void *argp1 = 0 ;
49965 int res1 = 0 ;
49966 int val2 ;
49967 int ecode2 = 0 ;
49968 int val3 ;
49969 int ecode3 = 0 ;
49970 PyObject * obj0 = 0 ;
49971 PyObject * obj1 = 0 ;
49972 PyObject * obj2 = 0 ;
49973 char * kwnames[] = {
49974 (char *) "self",(char *) "row",(char *) "col", NULL
49975 };
49976
49977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49979 if (!SWIG_IsOK(res1)) {
49980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
49981 }
49982 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49983 ecode2 = SWIG_AsVal_int(obj1, &val2);
49984 if (!SWIG_IsOK(ecode2)) {
49985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
49986 }
49987 arg2 = static_cast< int >(val2);
49988 ecode3 = SWIG_AsVal_int(obj2, &val3);
49989 if (!SWIG_IsOK(ecode3)) {
49990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
49991 }
49992 arg3 = static_cast< int >(val3);
49993 {
49994 PyThreadState* __tstate = wxPyBeginAllowThreads();
49995 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
49996 wxPyEndAllowThreads(__tstate);
49997 if (PyErr_Occurred()) SWIG_fail;
49998 }
49999 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50000 return resultobj;
50001 fail:
50002 return NULL;
50003 }
50004
50005
50006 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50007 PyObject *resultobj = 0;
50008 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50009 wxSize result;
50010 void *argp1 = 0 ;
50011 int res1 = 0 ;
50012 PyObject *swig_obj[1] ;
50013
50014 if (!args) SWIG_fail;
50015 swig_obj[0] = args;
50016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50017 if (!SWIG_IsOK(res1)) {
50018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50019 }
50020 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50021 {
50022 PyThreadState* __tstate = wxPyBeginAllowThreads();
50023 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50024 wxPyEndAllowThreads(__tstate);
50025 if (PyErr_Occurred()) SWIG_fail;
50026 }
50027 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50028 return resultobj;
50029 fail:
50030 return NULL;
50031 }
50032
50033
50034 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50035 PyObject *resultobj = 0;
50036 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50037 wxSize *arg2 = 0 ;
50038 void *argp1 = 0 ;
50039 int res1 = 0 ;
50040 wxSize temp2 ;
50041 PyObject * obj0 = 0 ;
50042 PyObject * obj1 = 0 ;
50043 char * kwnames[] = {
50044 (char *) "self",(char *) "sz", NULL
50045 };
50046
50047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50049 if (!SWIG_IsOK(res1)) {
50050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50051 }
50052 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50053 {
50054 arg2 = &temp2;
50055 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50056 }
50057 {
50058 PyThreadState* __tstate = wxPyBeginAllowThreads();
50059 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50060 wxPyEndAllowThreads(__tstate);
50061 if (PyErr_Occurred()) SWIG_fail;
50062 }
50063 resultobj = SWIG_Py_Void();
50064 return resultobj;
50065 fail:
50066 return NULL;
50067 }
50068
50069
50070 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50071 PyObject *resultobj = 0;
50072 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50073 wxWindow *arg2 = (wxWindow *) 0 ;
50074 wxGBPosition result;
50075 void *argp1 = 0 ;
50076 int res1 = 0 ;
50077 void *argp2 = 0 ;
50078 int res2 = 0 ;
50079
50080 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50082 if (!SWIG_IsOK(res1)) {
50083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50084 }
50085 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50086 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50087 if (!SWIG_IsOK(res2)) {
50088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50089 }
50090 arg2 = reinterpret_cast< wxWindow * >(argp2);
50091 {
50092 PyThreadState* __tstate = wxPyBeginAllowThreads();
50093 result = (arg1)->GetItemPosition(arg2);
50094 wxPyEndAllowThreads(__tstate);
50095 if (PyErr_Occurred()) SWIG_fail;
50096 }
50097 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50098 return resultobj;
50099 fail:
50100 return NULL;
50101 }
50102
50103
50104 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50105 PyObject *resultobj = 0;
50106 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50107 wxSizer *arg2 = (wxSizer *) 0 ;
50108 wxGBPosition result;
50109 void *argp1 = 0 ;
50110 int res1 = 0 ;
50111 void *argp2 = 0 ;
50112 int res2 = 0 ;
50113
50114 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50116 if (!SWIG_IsOK(res1)) {
50117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50118 }
50119 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50120 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50121 if (!SWIG_IsOK(res2)) {
50122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50123 }
50124 arg2 = reinterpret_cast< wxSizer * >(argp2);
50125 {
50126 PyThreadState* __tstate = wxPyBeginAllowThreads();
50127 result = (arg1)->GetItemPosition(arg2);
50128 wxPyEndAllowThreads(__tstate);
50129 if (PyErr_Occurred()) SWIG_fail;
50130 }
50131 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50132 return resultobj;
50133 fail:
50134 return NULL;
50135 }
50136
50137
50138 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50139 PyObject *resultobj = 0;
50140 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50141 size_t arg2 ;
50142 wxGBPosition result;
50143 void *argp1 = 0 ;
50144 int res1 = 0 ;
50145 size_t val2 ;
50146 int ecode2 = 0 ;
50147
50148 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50150 if (!SWIG_IsOK(res1)) {
50151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50152 }
50153 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50154 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50155 if (!SWIG_IsOK(ecode2)) {
50156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50157 }
50158 arg2 = static_cast< size_t >(val2);
50159 {
50160 PyThreadState* __tstate = wxPyBeginAllowThreads();
50161 result = (arg1)->GetItemPosition(arg2);
50162 wxPyEndAllowThreads(__tstate);
50163 if (PyErr_Occurred()) SWIG_fail;
50164 }
50165 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50166 return resultobj;
50167 fail:
50168 return NULL;
50169 }
50170
50171
50172 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50173 int argc;
50174 PyObject *argv[3];
50175
50176 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50177 --argc;
50178 if (argc == 2) {
50179 int _v = 0;
50180 {
50181 void *vptr = 0;
50182 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50183 _v = SWIG_CheckState(res);
50184 }
50185 if (!_v) goto check_1;
50186 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50187 }
50188 check_1:
50189
50190 if (argc == 2) {
50191 int _v = 0;
50192 {
50193 void *vptr = 0;
50194 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50195 _v = SWIG_CheckState(res);
50196 }
50197 if (!_v) goto check_2;
50198 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50199 }
50200 check_2:
50201
50202 if (argc == 2) {
50203 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50204 }
50205
50206 fail:
50207 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50208 return NULL;
50209 }
50210
50211
50212 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50213 PyObject *resultobj = 0;
50214 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50215 wxWindow *arg2 = (wxWindow *) 0 ;
50216 wxGBPosition *arg3 = 0 ;
50217 bool result;
50218 void *argp1 = 0 ;
50219 int res1 = 0 ;
50220 void *argp2 = 0 ;
50221 int res2 = 0 ;
50222 wxGBPosition temp3 ;
50223
50224 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50226 if (!SWIG_IsOK(res1)) {
50227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50228 }
50229 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50230 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50231 if (!SWIG_IsOK(res2)) {
50232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50233 }
50234 arg2 = reinterpret_cast< wxWindow * >(argp2);
50235 {
50236 arg3 = &temp3;
50237 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50238 }
50239 {
50240 PyThreadState* __tstate = wxPyBeginAllowThreads();
50241 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50242 wxPyEndAllowThreads(__tstate);
50243 if (PyErr_Occurred()) SWIG_fail;
50244 }
50245 {
50246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50247 }
50248 return resultobj;
50249 fail:
50250 return NULL;
50251 }
50252
50253
50254 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50255 PyObject *resultobj = 0;
50256 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50257 wxSizer *arg2 = (wxSizer *) 0 ;
50258 wxGBPosition *arg3 = 0 ;
50259 bool result;
50260 void *argp1 = 0 ;
50261 int res1 = 0 ;
50262 void *argp2 = 0 ;
50263 int res2 = 0 ;
50264 wxGBPosition temp3 ;
50265
50266 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50268 if (!SWIG_IsOK(res1)) {
50269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50270 }
50271 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50272 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50273 if (!SWIG_IsOK(res2)) {
50274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50275 }
50276 arg2 = reinterpret_cast< wxSizer * >(argp2);
50277 {
50278 arg3 = &temp3;
50279 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50280 }
50281 {
50282 PyThreadState* __tstate = wxPyBeginAllowThreads();
50283 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50284 wxPyEndAllowThreads(__tstate);
50285 if (PyErr_Occurred()) SWIG_fail;
50286 }
50287 {
50288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50289 }
50290 return resultobj;
50291 fail:
50292 return NULL;
50293 }
50294
50295
50296 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50297 PyObject *resultobj = 0;
50298 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50299 size_t arg2 ;
50300 wxGBPosition *arg3 = 0 ;
50301 bool result;
50302 void *argp1 = 0 ;
50303 int res1 = 0 ;
50304 size_t val2 ;
50305 int ecode2 = 0 ;
50306 wxGBPosition temp3 ;
50307
50308 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50310 if (!SWIG_IsOK(res1)) {
50311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50312 }
50313 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50314 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50315 if (!SWIG_IsOK(ecode2)) {
50316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50317 }
50318 arg2 = static_cast< size_t >(val2);
50319 {
50320 arg3 = &temp3;
50321 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50322 }
50323 {
50324 PyThreadState* __tstate = wxPyBeginAllowThreads();
50325 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50326 wxPyEndAllowThreads(__tstate);
50327 if (PyErr_Occurred()) SWIG_fail;
50328 }
50329 {
50330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50331 }
50332 return resultobj;
50333 fail:
50334 return NULL;
50335 }
50336
50337
50338 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50339 int argc;
50340 PyObject *argv[4];
50341
50342 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50343 --argc;
50344 if (argc == 3) {
50345 int _v = 0;
50346 {
50347 void *vptr = 0;
50348 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50349 _v = SWIG_CheckState(res);
50350 }
50351 if (!_v) goto check_1;
50352 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50353 }
50354 check_1:
50355
50356 if (argc == 3) {
50357 int _v = 0;
50358 {
50359 void *vptr = 0;
50360 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50361 _v = SWIG_CheckState(res);
50362 }
50363 if (!_v) goto check_2;
50364 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50365 }
50366 check_2:
50367
50368 if (argc == 3) {
50369 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50370 }
50371
50372 fail:
50373 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50374 return NULL;
50375 }
50376
50377
50378 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50379 PyObject *resultobj = 0;
50380 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50381 wxWindow *arg2 = (wxWindow *) 0 ;
50382 wxGBSpan result;
50383 void *argp1 = 0 ;
50384 int res1 = 0 ;
50385 void *argp2 = 0 ;
50386 int res2 = 0 ;
50387
50388 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50390 if (!SWIG_IsOK(res1)) {
50391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50392 }
50393 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50394 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50395 if (!SWIG_IsOK(res2)) {
50396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50397 }
50398 arg2 = reinterpret_cast< wxWindow * >(argp2);
50399 {
50400 PyThreadState* __tstate = wxPyBeginAllowThreads();
50401 result = (arg1)->GetItemSpan(arg2);
50402 wxPyEndAllowThreads(__tstate);
50403 if (PyErr_Occurred()) SWIG_fail;
50404 }
50405 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50406 return resultobj;
50407 fail:
50408 return NULL;
50409 }
50410
50411
50412 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50413 PyObject *resultobj = 0;
50414 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50415 wxSizer *arg2 = (wxSizer *) 0 ;
50416 wxGBSpan result;
50417 void *argp1 = 0 ;
50418 int res1 = 0 ;
50419 void *argp2 = 0 ;
50420 int res2 = 0 ;
50421
50422 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50424 if (!SWIG_IsOK(res1)) {
50425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50426 }
50427 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50428 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50429 if (!SWIG_IsOK(res2)) {
50430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50431 }
50432 arg2 = reinterpret_cast< wxSizer * >(argp2);
50433 {
50434 PyThreadState* __tstate = wxPyBeginAllowThreads();
50435 result = (arg1)->GetItemSpan(arg2);
50436 wxPyEndAllowThreads(__tstate);
50437 if (PyErr_Occurred()) SWIG_fail;
50438 }
50439 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50440 return resultobj;
50441 fail:
50442 return NULL;
50443 }
50444
50445
50446 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50447 PyObject *resultobj = 0;
50448 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50449 size_t arg2 ;
50450 wxGBSpan result;
50451 void *argp1 = 0 ;
50452 int res1 = 0 ;
50453 size_t val2 ;
50454 int ecode2 = 0 ;
50455
50456 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50458 if (!SWIG_IsOK(res1)) {
50459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50460 }
50461 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50462 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50463 if (!SWIG_IsOK(ecode2)) {
50464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50465 }
50466 arg2 = static_cast< size_t >(val2);
50467 {
50468 PyThreadState* __tstate = wxPyBeginAllowThreads();
50469 result = (arg1)->GetItemSpan(arg2);
50470 wxPyEndAllowThreads(__tstate);
50471 if (PyErr_Occurred()) SWIG_fail;
50472 }
50473 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50474 return resultobj;
50475 fail:
50476 return NULL;
50477 }
50478
50479
50480 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50481 int argc;
50482 PyObject *argv[3];
50483
50484 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50485 --argc;
50486 if (argc == 2) {
50487 int _v = 0;
50488 {
50489 void *vptr = 0;
50490 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50491 _v = SWIG_CheckState(res);
50492 }
50493 if (!_v) goto check_1;
50494 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50495 }
50496 check_1:
50497
50498 if (argc == 2) {
50499 int _v = 0;
50500 {
50501 void *vptr = 0;
50502 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50503 _v = SWIG_CheckState(res);
50504 }
50505 if (!_v) goto check_2;
50506 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50507 }
50508 check_2:
50509
50510 if (argc == 2) {
50511 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50512 }
50513
50514 fail:
50515 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50516 return NULL;
50517 }
50518
50519
50520 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50521 PyObject *resultobj = 0;
50522 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50523 wxWindow *arg2 = (wxWindow *) 0 ;
50524 wxGBSpan *arg3 = 0 ;
50525 bool result;
50526 void *argp1 = 0 ;
50527 int res1 = 0 ;
50528 void *argp2 = 0 ;
50529 int res2 = 0 ;
50530 wxGBSpan temp3 ;
50531
50532 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50534 if (!SWIG_IsOK(res1)) {
50535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50536 }
50537 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50538 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50539 if (!SWIG_IsOK(res2)) {
50540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50541 }
50542 arg2 = reinterpret_cast< wxWindow * >(argp2);
50543 {
50544 arg3 = &temp3;
50545 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50546 }
50547 {
50548 PyThreadState* __tstate = wxPyBeginAllowThreads();
50549 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50550 wxPyEndAllowThreads(__tstate);
50551 if (PyErr_Occurred()) SWIG_fail;
50552 }
50553 {
50554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50555 }
50556 return resultobj;
50557 fail:
50558 return NULL;
50559 }
50560
50561
50562 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50563 PyObject *resultobj = 0;
50564 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50565 wxSizer *arg2 = (wxSizer *) 0 ;
50566 wxGBSpan *arg3 = 0 ;
50567 bool result;
50568 void *argp1 = 0 ;
50569 int res1 = 0 ;
50570 void *argp2 = 0 ;
50571 int res2 = 0 ;
50572 wxGBSpan temp3 ;
50573
50574 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50576 if (!SWIG_IsOK(res1)) {
50577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50578 }
50579 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50580 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50581 if (!SWIG_IsOK(res2)) {
50582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50583 }
50584 arg2 = reinterpret_cast< wxSizer * >(argp2);
50585 {
50586 arg3 = &temp3;
50587 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50588 }
50589 {
50590 PyThreadState* __tstate = wxPyBeginAllowThreads();
50591 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50592 wxPyEndAllowThreads(__tstate);
50593 if (PyErr_Occurred()) SWIG_fail;
50594 }
50595 {
50596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50597 }
50598 return resultobj;
50599 fail:
50600 return NULL;
50601 }
50602
50603
50604 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50605 PyObject *resultobj = 0;
50606 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50607 size_t arg2 ;
50608 wxGBSpan *arg3 = 0 ;
50609 bool result;
50610 void *argp1 = 0 ;
50611 int res1 = 0 ;
50612 size_t val2 ;
50613 int ecode2 = 0 ;
50614 wxGBSpan temp3 ;
50615
50616 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50618 if (!SWIG_IsOK(res1)) {
50619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50620 }
50621 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50622 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50623 if (!SWIG_IsOK(ecode2)) {
50624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50625 }
50626 arg2 = static_cast< size_t >(val2);
50627 {
50628 arg3 = &temp3;
50629 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50630 }
50631 {
50632 PyThreadState* __tstate = wxPyBeginAllowThreads();
50633 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50634 wxPyEndAllowThreads(__tstate);
50635 if (PyErr_Occurred()) SWIG_fail;
50636 }
50637 {
50638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50639 }
50640 return resultobj;
50641 fail:
50642 return NULL;
50643 }
50644
50645
50646 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50647 int argc;
50648 PyObject *argv[4];
50649
50650 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50651 --argc;
50652 if (argc == 3) {
50653 int _v = 0;
50654 {
50655 void *vptr = 0;
50656 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50657 _v = SWIG_CheckState(res);
50658 }
50659 if (!_v) goto check_1;
50660 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50661 }
50662 check_1:
50663
50664 if (argc == 3) {
50665 int _v = 0;
50666 {
50667 void *vptr = 0;
50668 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50669 _v = SWIG_CheckState(res);
50670 }
50671 if (!_v) goto check_2;
50672 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50673 }
50674 check_2:
50675
50676 if (argc == 3) {
50677 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50678 }
50679
50680 fail:
50681 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50682 return NULL;
50683 }
50684
50685
50686 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50687 PyObject *resultobj = 0;
50688 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50689 wxWindow *arg2 = (wxWindow *) 0 ;
50690 wxGBSizerItem *result = 0 ;
50691 void *argp1 = 0 ;
50692 int res1 = 0 ;
50693 void *argp2 = 0 ;
50694 int res2 = 0 ;
50695
50696 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50698 if (!SWIG_IsOK(res1)) {
50699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50700 }
50701 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50702 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50703 if (!SWIG_IsOK(res2)) {
50704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50705 }
50706 arg2 = reinterpret_cast< wxWindow * >(argp2);
50707 {
50708 PyThreadState* __tstate = wxPyBeginAllowThreads();
50709 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50710 wxPyEndAllowThreads(__tstate);
50711 if (PyErr_Occurred()) SWIG_fail;
50712 }
50713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50714 return resultobj;
50715 fail:
50716 return NULL;
50717 }
50718
50719
50720 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50721 PyObject *resultobj = 0;
50722 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50723 wxSizer *arg2 = (wxSizer *) 0 ;
50724 wxGBSizerItem *result = 0 ;
50725 void *argp1 = 0 ;
50726 int res1 = 0 ;
50727 void *argp2 = 0 ;
50728 int res2 = 0 ;
50729
50730 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50732 if (!SWIG_IsOK(res1)) {
50733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50734 }
50735 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50736 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50737 if (!SWIG_IsOK(res2)) {
50738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50739 }
50740 arg2 = reinterpret_cast< wxSizer * >(argp2);
50741 {
50742 PyThreadState* __tstate = wxPyBeginAllowThreads();
50743 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50744 wxPyEndAllowThreads(__tstate);
50745 if (PyErr_Occurred()) SWIG_fail;
50746 }
50747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50748 return resultobj;
50749 fail:
50750 return NULL;
50751 }
50752
50753
50754 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50755 int argc;
50756 PyObject *argv[3];
50757
50758 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50759 --argc;
50760 if (argc == 2) {
50761 int _v = 0;
50762 {
50763 void *vptr = 0;
50764 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50765 _v = SWIG_CheckState(res);
50766 }
50767 if (!_v) goto check_1;
50768 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50769 }
50770 check_1:
50771
50772 if (argc == 2) {
50773 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50774 }
50775
50776 fail:
50777 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50778 return NULL;
50779 }
50780
50781
50782 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50783 PyObject *resultobj = 0;
50784 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50785 wxGBPosition *arg2 = 0 ;
50786 wxGBSizerItem *result = 0 ;
50787 void *argp1 = 0 ;
50788 int res1 = 0 ;
50789 wxGBPosition temp2 ;
50790 PyObject * obj0 = 0 ;
50791 PyObject * obj1 = 0 ;
50792 char * kwnames[] = {
50793 (char *) "self",(char *) "pos", NULL
50794 };
50795
50796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50798 if (!SWIG_IsOK(res1)) {
50799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50800 }
50801 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50802 {
50803 arg2 = &temp2;
50804 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50805 }
50806 {
50807 PyThreadState* __tstate = wxPyBeginAllowThreads();
50808 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50809 wxPyEndAllowThreads(__tstate);
50810 if (PyErr_Occurred()) SWIG_fail;
50811 }
50812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50813 return resultobj;
50814 fail:
50815 return NULL;
50816 }
50817
50818
50819 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50820 PyObject *resultobj = 0;
50821 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50822 wxPoint *arg2 = 0 ;
50823 wxGBSizerItem *result = 0 ;
50824 void *argp1 = 0 ;
50825 int res1 = 0 ;
50826 wxPoint temp2 ;
50827 PyObject * obj0 = 0 ;
50828 PyObject * obj1 = 0 ;
50829 char * kwnames[] = {
50830 (char *) "self",(char *) "pt", NULL
50831 };
50832
50833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50835 if (!SWIG_IsOK(res1)) {
50836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50837 }
50838 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50839 {
50840 arg2 = &temp2;
50841 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50842 }
50843 {
50844 PyThreadState* __tstate = wxPyBeginAllowThreads();
50845 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50846 wxPyEndAllowThreads(__tstate);
50847 if (PyErr_Occurred()) SWIG_fail;
50848 }
50849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50850 return resultobj;
50851 fail:
50852 return NULL;
50853 }
50854
50855
50856 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50857 PyObject *resultobj = 0;
50858 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50859 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50860 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50861 bool result;
50862 void *argp1 = 0 ;
50863 int res1 = 0 ;
50864 void *argp2 = 0 ;
50865 int res2 = 0 ;
50866 void *argp3 = 0 ;
50867 int res3 = 0 ;
50868 PyObject * obj0 = 0 ;
50869 PyObject * obj1 = 0 ;
50870 PyObject * obj2 = 0 ;
50871 char * kwnames[] = {
50872 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50873 };
50874
50875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50877 if (!SWIG_IsOK(res1)) {
50878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50879 }
50880 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50881 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50882 if (!SWIG_IsOK(res2)) {
50883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50884 }
50885 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50886 if (obj2) {
50887 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50888 if (!SWIG_IsOK(res3)) {
50889 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
50890 }
50891 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
50892 }
50893 {
50894 PyThreadState* __tstate = wxPyBeginAllowThreads();
50895 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
50896 wxPyEndAllowThreads(__tstate);
50897 if (PyErr_Occurred()) SWIG_fail;
50898 }
50899 {
50900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50901 }
50902 return resultobj;
50903 fail:
50904 return NULL;
50905 }
50906
50907
50908 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50909 PyObject *resultobj = 0;
50910 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50911 wxGBPosition *arg2 = 0 ;
50912 wxGBSpan *arg3 = 0 ;
50913 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
50914 bool result;
50915 void *argp1 = 0 ;
50916 int res1 = 0 ;
50917 wxGBPosition temp2 ;
50918 wxGBSpan temp3 ;
50919 void *argp4 = 0 ;
50920 int res4 = 0 ;
50921 PyObject * obj0 = 0 ;
50922 PyObject * obj1 = 0 ;
50923 PyObject * obj2 = 0 ;
50924 PyObject * obj3 = 0 ;
50925 char * kwnames[] = {
50926 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
50927 };
50928
50929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50931 if (!SWIG_IsOK(res1)) {
50932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50933 }
50934 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50935 {
50936 arg2 = &temp2;
50937 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50938 }
50939 {
50940 arg3 = &temp3;
50941 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50942 }
50943 if (obj3) {
50944 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50945 if (!SWIG_IsOK(res4)) {
50946 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
50947 }
50948 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
50949 }
50950 {
50951 PyThreadState* __tstate = wxPyBeginAllowThreads();
50952 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
50953 wxPyEndAllowThreads(__tstate);
50954 if (PyErr_Occurred()) SWIG_fail;
50955 }
50956 {
50957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50958 }
50959 return resultobj;
50960 fail:
50961 return NULL;
50962 }
50963
50964
50965 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50966 PyObject *obj;
50967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50968 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
50969 return SWIG_Py_Void();
50970 }
50971
50972 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50973 return SWIG_Python_InitShadowInstance(args);
50974 }
50975
50976 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50977 PyObject *resultobj = 0;
50978 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
50979 wxRelationship arg2 ;
50980 wxWindow *arg3 = (wxWindow *) 0 ;
50981 wxEdge arg4 ;
50982 int arg5 = (int) 0 ;
50983 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
50984 void *argp1 = 0 ;
50985 int res1 = 0 ;
50986 int val2 ;
50987 int ecode2 = 0 ;
50988 void *argp3 = 0 ;
50989 int res3 = 0 ;
50990 int val4 ;
50991 int ecode4 = 0 ;
50992 int val5 ;
50993 int ecode5 = 0 ;
50994 int val6 ;
50995 int ecode6 = 0 ;
50996 PyObject * obj0 = 0 ;
50997 PyObject * obj1 = 0 ;
50998 PyObject * obj2 = 0 ;
50999 PyObject * obj3 = 0 ;
51000 PyObject * obj4 = 0 ;
51001 PyObject * obj5 = 0 ;
51002 char * kwnames[] = {
51003 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51004 };
51005
51006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51008 if (!SWIG_IsOK(res1)) {
51009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51010 }
51011 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51012 ecode2 = SWIG_AsVal_int(obj1, &val2);
51013 if (!SWIG_IsOK(ecode2)) {
51014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51015 }
51016 arg2 = static_cast< wxRelationship >(val2);
51017 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51018 if (!SWIG_IsOK(res3)) {
51019 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51020 }
51021 arg3 = reinterpret_cast< wxWindow * >(argp3);
51022 ecode4 = SWIG_AsVal_int(obj3, &val4);
51023 if (!SWIG_IsOK(ecode4)) {
51024 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51025 }
51026 arg4 = static_cast< wxEdge >(val4);
51027 if (obj4) {
51028 ecode5 = SWIG_AsVal_int(obj4, &val5);
51029 if (!SWIG_IsOK(ecode5)) {
51030 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51031 }
51032 arg5 = static_cast< int >(val5);
51033 }
51034 if (obj5) {
51035 ecode6 = SWIG_AsVal_int(obj5, &val6);
51036 if (!SWIG_IsOK(ecode6)) {
51037 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51038 }
51039 arg6 = static_cast< int >(val6);
51040 }
51041 {
51042 PyThreadState* __tstate = wxPyBeginAllowThreads();
51043 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51044 wxPyEndAllowThreads(__tstate);
51045 if (PyErr_Occurred()) SWIG_fail;
51046 }
51047 resultobj = SWIG_Py_Void();
51048 return resultobj;
51049 fail:
51050 return NULL;
51051 }
51052
51053
51054 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51055 PyObject *resultobj = 0;
51056 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51057 wxWindow *arg2 = (wxWindow *) 0 ;
51058 int arg3 = (int) 0 ;
51059 void *argp1 = 0 ;
51060 int res1 = 0 ;
51061 void *argp2 = 0 ;
51062 int res2 = 0 ;
51063 int val3 ;
51064 int ecode3 = 0 ;
51065 PyObject * obj0 = 0 ;
51066 PyObject * obj1 = 0 ;
51067 PyObject * obj2 = 0 ;
51068 char * kwnames[] = {
51069 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51070 };
51071
51072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51074 if (!SWIG_IsOK(res1)) {
51075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51076 }
51077 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51078 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51079 if (!SWIG_IsOK(res2)) {
51080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51081 }
51082 arg2 = reinterpret_cast< wxWindow * >(argp2);
51083 if (obj2) {
51084 ecode3 = SWIG_AsVal_int(obj2, &val3);
51085 if (!SWIG_IsOK(ecode3)) {
51086 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51087 }
51088 arg3 = static_cast< int >(val3);
51089 }
51090 {
51091 PyThreadState* __tstate = wxPyBeginAllowThreads();
51092 (arg1)->LeftOf(arg2,arg3);
51093 wxPyEndAllowThreads(__tstate);
51094 if (PyErr_Occurred()) SWIG_fail;
51095 }
51096 resultobj = SWIG_Py_Void();
51097 return resultobj;
51098 fail:
51099 return NULL;
51100 }
51101
51102
51103 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51104 PyObject *resultobj = 0;
51105 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51106 wxWindow *arg2 = (wxWindow *) 0 ;
51107 int arg3 = (int) 0 ;
51108 void *argp1 = 0 ;
51109 int res1 = 0 ;
51110 void *argp2 = 0 ;
51111 int res2 = 0 ;
51112 int val3 ;
51113 int ecode3 = 0 ;
51114 PyObject * obj0 = 0 ;
51115 PyObject * obj1 = 0 ;
51116 PyObject * obj2 = 0 ;
51117 char * kwnames[] = {
51118 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51119 };
51120
51121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51123 if (!SWIG_IsOK(res1)) {
51124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51125 }
51126 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51127 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51128 if (!SWIG_IsOK(res2)) {
51129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51130 }
51131 arg2 = reinterpret_cast< wxWindow * >(argp2);
51132 if (obj2) {
51133 ecode3 = SWIG_AsVal_int(obj2, &val3);
51134 if (!SWIG_IsOK(ecode3)) {
51135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51136 }
51137 arg3 = static_cast< int >(val3);
51138 }
51139 {
51140 PyThreadState* __tstate = wxPyBeginAllowThreads();
51141 (arg1)->RightOf(arg2,arg3);
51142 wxPyEndAllowThreads(__tstate);
51143 if (PyErr_Occurred()) SWIG_fail;
51144 }
51145 resultobj = SWIG_Py_Void();
51146 return resultobj;
51147 fail:
51148 return NULL;
51149 }
51150
51151
51152 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51153 PyObject *resultobj = 0;
51154 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51155 wxWindow *arg2 = (wxWindow *) 0 ;
51156 int arg3 = (int) 0 ;
51157 void *argp1 = 0 ;
51158 int res1 = 0 ;
51159 void *argp2 = 0 ;
51160 int res2 = 0 ;
51161 int val3 ;
51162 int ecode3 = 0 ;
51163 PyObject * obj0 = 0 ;
51164 PyObject * obj1 = 0 ;
51165 PyObject * obj2 = 0 ;
51166 char * kwnames[] = {
51167 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51168 };
51169
51170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51172 if (!SWIG_IsOK(res1)) {
51173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51174 }
51175 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51176 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51177 if (!SWIG_IsOK(res2)) {
51178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51179 }
51180 arg2 = reinterpret_cast< wxWindow * >(argp2);
51181 if (obj2) {
51182 ecode3 = SWIG_AsVal_int(obj2, &val3);
51183 if (!SWIG_IsOK(ecode3)) {
51184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51185 }
51186 arg3 = static_cast< int >(val3);
51187 }
51188 {
51189 PyThreadState* __tstate = wxPyBeginAllowThreads();
51190 (arg1)->Above(arg2,arg3);
51191 wxPyEndAllowThreads(__tstate);
51192 if (PyErr_Occurred()) SWIG_fail;
51193 }
51194 resultobj = SWIG_Py_Void();
51195 return resultobj;
51196 fail:
51197 return NULL;
51198 }
51199
51200
51201 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51202 PyObject *resultobj = 0;
51203 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51204 wxWindow *arg2 = (wxWindow *) 0 ;
51205 int arg3 = (int) 0 ;
51206 void *argp1 = 0 ;
51207 int res1 = 0 ;
51208 void *argp2 = 0 ;
51209 int res2 = 0 ;
51210 int val3 ;
51211 int ecode3 = 0 ;
51212 PyObject * obj0 = 0 ;
51213 PyObject * obj1 = 0 ;
51214 PyObject * obj2 = 0 ;
51215 char * kwnames[] = {
51216 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51217 };
51218
51219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51221 if (!SWIG_IsOK(res1)) {
51222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51223 }
51224 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51226 if (!SWIG_IsOK(res2)) {
51227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51228 }
51229 arg2 = reinterpret_cast< wxWindow * >(argp2);
51230 if (obj2) {
51231 ecode3 = SWIG_AsVal_int(obj2, &val3);
51232 if (!SWIG_IsOK(ecode3)) {
51233 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51234 }
51235 arg3 = static_cast< int >(val3);
51236 }
51237 {
51238 PyThreadState* __tstate = wxPyBeginAllowThreads();
51239 (arg1)->Below(arg2,arg3);
51240 wxPyEndAllowThreads(__tstate);
51241 if (PyErr_Occurred()) SWIG_fail;
51242 }
51243 resultobj = SWIG_Py_Void();
51244 return resultobj;
51245 fail:
51246 return NULL;
51247 }
51248
51249
51250 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51251 PyObject *resultobj = 0;
51252 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51253 wxWindow *arg2 = (wxWindow *) 0 ;
51254 wxEdge arg3 ;
51255 int arg4 = (int) 0 ;
51256 void *argp1 = 0 ;
51257 int res1 = 0 ;
51258 void *argp2 = 0 ;
51259 int res2 = 0 ;
51260 int val3 ;
51261 int ecode3 = 0 ;
51262 int val4 ;
51263 int ecode4 = 0 ;
51264 PyObject * obj0 = 0 ;
51265 PyObject * obj1 = 0 ;
51266 PyObject * obj2 = 0 ;
51267 PyObject * obj3 = 0 ;
51268 char * kwnames[] = {
51269 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51270 };
51271
51272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51274 if (!SWIG_IsOK(res1)) {
51275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51276 }
51277 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51279 if (!SWIG_IsOK(res2)) {
51280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51281 }
51282 arg2 = reinterpret_cast< wxWindow * >(argp2);
51283 ecode3 = SWIG_AsVal_int(obj2, &val3);
51284 if (!SWIG_IsOK(ecode3)) {
51285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51286 }
51287 arg3 = static_cast< wxEdge >(val3);
51288 if (obj3) {
51289 ecode4 = SWIG_AsVal_int(obj3, &val4);
51290 if (!SWIG_IsOK(ecode4)) {
51291 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51292 }
51293 arg4 = static_cast< int >(val4);
51294 }
51295 {
51296 PyThreadState* __tstate = wxPyBeginAllowThreads();
51297 (arg1)->SameAs(arg2,arg3,arg4);
51298 wxPyEndAllowThreads(__tstate);
51299 if (PyErr_Occurred()) SWIG_fail;
51300 }
51301 resultobj = SWIG_Py_Void();
51302 return resultobj;
51303 fail:
51304 return NULL;
51305 }
51306
51307
51308 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51309 PyObject *resultobj = 0;
51310 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51311 wxWindow *arg2 = (wxWindow *) 0 ;
51312 wxEdge arg3 ;
51313 int arg4 ;
51314 void *argp1 = 0 ;
51315 int res1 = 0 ;
51316 void *argp2 = 0 ;
51317 int res2 = 0 ;
51318 int val3 ;
51319 int ecode3 = 0 ;
51320 int val4 ;
51321 int ecode4 = 0 ;
51322 PyObject * obj0 = 0 ;
51323 PyObject * obj1 = 0 ;
51324 PyObject * obj2 = 0 ;
51325 PyObject * obj3 = 0 ;
51326 char * kwnames[] = {
51327 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51328 };
51329
51330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51332 if (!SWIG_IsOK(res1)) {
51333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51334 }
51335 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51336 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51337 if (!SWIG_IsOK(res2)) {
51338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51339 }
51340 arg2 = reinterpret_cast< wxWindow * >(argp2);
51341 ecode3 = SWIG_AsVal_int(obj2, &val3);
51342 if (!SWIG_IsOK(ecode3)) {
51343 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51344 }
51345 arg3 = static_cast< wxEdge >(val3);
51346 ecode4 = SWIG_AsVal_int(obj3, &val4);
51347 if (!SWIG_IsOK(ecode4)) {
51348 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51349 }
51350 arg4 = static_cast< int >(val4);
51351 {
51352 PyThreadState* __tstate = wxPyBeginAllowThreads();
51353 (arg1)->PercentOf(arg2,arg3,arg4);
51354 wxPyEndAllowThreads(__tstate);
51355 if (PyErr_Occurred()) SWIG_fail;
51356 }
51357 resultobj = SWIG_Py_Void();
51358 return resultobj;
51359 fail:
51360 return NULL;
51361 }
51362
51363
51364 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51365 PyObject *resultobj = 0;
51366 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51367 int arg2 ;
51368 void *argp1 = 0 ;
51369 int res1 = 0 ;
51370 int val2 ;
51371 int ecode2 = 0 ;
51372 PyObject * obj0 = 0 ;
51373 PyObject * obj1 = 0 ;
51374 char * kwnames[] = {
51375 (char *) "self",(char *) "val", NULL
51376 };
51377
51378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51380 if (!SWIG_IsOK(res1)) {
51381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51382 }
51383 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51384 ecode2 = SWIG_AsVal_int(obj1, &val2);
51385 if (!SWIG_IsOK(ecode2)) {
51386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51387 }
51388 arg2 = static_cast< int >(val2);
51389 {
51390 PyThreadState* __tstate = wxPyBeginAllowThreads();
51391 (arg1)->Absolute(arg2);
51392 wxPyEndAllowThreads(__tstate);
51393 if (PyErr_Occurred()) SWIG_fail;
51394 }
51395 resultobj = SWIG_Py_Void();
51396 return resultobj;
51397 fail:
51398 return NULL;
51399 }
51400
51401
51402 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51403 PyObject *resultobj = 0;
51404 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51405 void *argp1 = 0 ;
51406 int res1 = 0 ;
51407 PyObject *swig_obj[1] ;
51408
51409 if (!args) SWIG_fail;
51410 swig_obj[0] = args;
51411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51412 if (!SWIG_IsOK(res1)) {
51413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51414 }
51415 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51416 {
51417 PyThreadState* __tstate = wxPyBeginAllowThreads();
51418 (arg1)->Unconstrained();
51419 wxPyEndAllowThreads(__tstate);
51420 if (PyErr_Occurred()) SWIG_fail;
51421 }
51422 resultobj = SWIG_Py_Void();
51423 return resultobj;
51424 fail:
51425 return NULL;
51426 }
51427
51428
51429 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51430 PyObject *resultobj = 0;
51431 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51432 void *argp1 = 0 ;
51433 int res1 = 0 ;
51434 PyObject *swig_obj[1] ;
51435
51436 if (!args) SWIG_fail;
51437 swig_obj[0] = args;
51438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51439 if (!SWIG_IsOK(res1)) {
51440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51441 }
51442 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51443 {
51444 PyThreadState* __tstate = wxPyBeginAllowThreads();
51445 (arg1)->AsIs();
51446 wxPyEndAllowThreads(__tstate);
51447 if (PyErr_Occurred()) SWIG_fail;
51448 }
51449 resultobj = SWIG_Py_Void();
51450 return resultobj;
51451 fail:
51452 return NULL;
51453 }
51454
51455
51456 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51457 PyObject *resultobj = 0;
51458 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51459 wxWindow *result = 0 ;
51460 void *argp1 = 0 ;
51461 int res1 = 0 ;
51462 PyObject *swig_obj[1] ;
51463
51464 if (!args) SWIG_fail;
51465 swig_obj[0] = args;
51466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51467 if (!SWIG_IsOK(res1)) {
51468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51469 }
51470 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51471 {
51472 PyThreadState* __tstate = wxPyBeginAllowThreads();
51473 result = (wxWindow *)(arg1)->GetOtherWindow();
51474 wxPyEndAllowThreads(__tstate);
51475 if (PyErr_Occurred()) SWIG_fail;
51476 }
51477 {
51478 resultobj = wxPyMake_wxObject(result, 0);
51479 }
51480 return resultobj;
51481 fail:
51482 return NULL;
51483 }
51484
51485
51486 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51487 PyObject *resultobj = 0;
51488 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51489 wxEdge result;
51490 void *argp1 = 0 ;
51491 int res1 = 0 ;
51492 PyObject *swig_obj[1] ;
51493
51494 if (!args) SWIG_fail;
51495 swig_obj[0] = args;
51496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51497 if (!SWIG_IsOK(res1)) {
51498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51499 }
51500 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51501 {
51502 PyThreadState* __tstate = wxPyBeginAllowThreads();
51503 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51504 wxPyEndAllowThreads(__tstate);
51505 if (PyErr_Occurred()) SWIG_fail;
51506 }
51507 resultobj = SWIG_From_int(static_cast< int >(result));
51508 return resultobj;
51509 fail:
51510 return NULL;
51511 }
51512
51513
51514 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51515 PyObject *resultobj = 0;
51516 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51517 wxEdge arg2 ;
51518 void *argp1 = 0 ;
51519 int res1 = 0 ;
51520 int val2 ;
51521 int ecode2 = 0 ;
51522 PyObject * obj0 = 0 ;
51523 PyObject * obj1 = 0 ;
51524 char * kwnames[] = {
51525 (char *) "self",(char *) "which", NULL
51526 };
51527
51528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51530 if (!SWIG_IsOK(res1)) {
51531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51532 }
51533 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51534 ecode2 = SWIG_AsVal_int(obj1, &val2);
51535 if (!SWIG_IsOK(ecode2)) {
51536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51537 }
51538 arg2 = static_cast< wxEdge >(val2);
51539 {
51540 PyThreadState* __tstate = wxPyBeginAllowThreads();
51541 (arg1)->SetEdge(arg2);
51542 wxPyEndAllowThreads(__tstate);
51543 if (PyErr_Occurred()) SWIG_fail;
51544 }
51545 resultobj = SWIG_Py_Void();
51546 return resultobj;
51547 fail:
51548 return NULL;
51549 }
51550
51551
51552 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51553 PyObject *resultobj = 0;
51554 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51555 int arg2 ;
51556 void *argp1 = 0 ;
51557 int res1 = 0 ;
51558 int val2 ;
51559 int ecode2 = 0 ;
51560 PyObject * obj0 = 0 ;
51561 PyObject * obj1 = 0 ;
51562 char * kwnames[] = {
51563 (char *) "self",(char *) "v", NULL
51564 };
51565
51566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51568 if (!SWIG_IsOK(res1)) {
51569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51570 }
51571 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51572 ecode2 = SWIG_AsVal_int(obj1, &val2);
51573 if (!SWIG_IsOK(ecode2)) {
51574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51575 }
51576 arg2 = static_cast< int >(val2);
51577 {
51578 PyThreadState* __tstate = wxPyBeginAllowThreads();
51579 (arg1)->SetValue(arg2);
51580 wxPyEndAllowThreads(__tstate);
51581 if (PyErr_Occurred()) SWIG_fail;
51582 }
51583 resultobj = SWIG_Py_Void();
51584 return resultobj;
51585 fail:
51586 return NULL;
51587 }
51588
51589
51590 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51591 PyObject *resultobj = 0;
51592 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51593 int result;
51594 void *argp1 = 0 ;
51595 int res1 = 0 ;
51596 PyObject *swig_obj[1] ;
51597
51598 if (!args) SWIG_fail;
51599 swig_obj[0] = args;
51600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51601 if (!SWIG_IsOK(res1)) {
51602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51603 }
51604 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51605 {
51606 PyThreadState* __tstate = wxPyBeginAllowThreads();
51607 result = (int)(arg1)->GetMargin();
51608 wxPyEndAllowThreads(__tstate);
51609 if (PyErr_Occurred()) SWIG_fail;
51610 }
51611 resultobj = SWIG_From_int(static_cast< int >(result));
51612 return resultobj;
51613 fail:
51614 return NULL;
51615 }
51616
51617
51618 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51619 PyObject *resultobj = 0;
51620 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51621 int arg2 ;
51622 void *argp1 = 0 ;
51623 int res1 = 0 ;
51624 int val2 ;
51625 int ecode2 = 0 ;
51626 PyObject * obj0 = 0 ;
51627 PyObject * obj1 = 0 ;
51628 char * kwnames[] = {
51629 (char *) "self",(char *) "m", NULL
51630 };
51631
51632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51634 if (!SWIG_IsOK(res1)) {
51635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51636 }
51637 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51638 ecode2 = SWIG_AsVal_int(obj1, &val2);
51639 if (!SWIG_IsOK(ecode2)) {
51640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51641 }
51642 arg2 = static_cast< int >(val2);
51643 {
51644 PyThreadState* __tstate = wxPyBeginAllowThreads();
51645 (arg1)->SetMargin(arg2);
51646 wxPyEndAllowThreads(__tstate);
51647 if (PyErr_Occurred()) SWIG_fail;
51648 }
51649 resultobj = SWIG_Py_Void();
51650 return resultobj;
51651 fail:
51652 return NULL;
51653 }
51654
51655
51656 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51657 PyObject *resultobj = 0;
51658 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51659 int result;
51660 void *argp1 = 0 ;
51661 int res1 = 0 ;
51662 PyObject *swig_obj[1] ;
51663
51664 if (!args) SWIG_fail;
51665 swig_obj[0] = args;
51666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51667 if (!SWIG_IsOK(res1)) {
51668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51669 }
51670 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51671 {
51672 PyThreadState* __tstate = wxPyBeginAllowThreads();
51673 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51674 wxPyEndAllowThreads(__tstate);
51675 if (PyErr_Occurred()) SWIG_fail;
51676 }
51677 resultobj = SWIG_From_int(static_cast< int >(result));
51678 return resultobj;
51679 fail:
51680 return NULL;
51681 }
51682
51683
51684 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51685 PyObject *resultobj = 0;
51686 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51687 int result;
51688 void *argp1 = 0 ;
51689 int res1 = 0 ;
51690 PyObject *swig_obj[1] ;
51691
51692 if (!args) SWIG_fail;
51693 swig_obj[0] = args;
51694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51695 if (!SWIG_IsOK(res1)) {
51696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51697 }
51698 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51699 {
51700 PyThreadState* __tstate = wxPyBeginAllowThreads();
51701 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51702 wxPyEndAllowThreads(__tstate);
51703 if (PyErr_Occurred()) SWIG_fail;
51704 }
51705 resultobj = SWIG_From_int(static_cast< int >(result));
51706 return resultobj;
51707 fail:
51708 return NULL;
51709 }
51710
51711
51712 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51713 PyObject *resultobj = 0;
51714 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51715 int result;
51716 void *argp1 = 0 ;
51717 int res1 = 0 ;
51718 PyObject *swig_obj[1] ;
51719
51720 if (!args) SWIG_fail;
51721 swig_obj[0] = args;
51722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51723 if (!SWIG_IsOK(res1)) {
51724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51725 }
51726 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51727 {
51728 PyThreadState* __tstate = wxPyBeginAllowThreads();
51729 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51730 wxPyEndAllowThreads(__tstate);
51731 if (PyErr_Occurred()) SWIG_fail;
51732 }
51733 resultobj = SWIG_From_int(static_cast< int >(result));
51734 return resultobj;
51735 fail:
51736 return NULL;
51737 }
51738
51739
51740 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51741 PyObject *resultobj = 0;
51742 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51743 bool result;
51744 void *argp1 = 0 ;
51745 int res1 = 0 ;
51746 PyObject *swig_obj[1] ;
51747
51748 if (!args) SWIG_fail;
51749 swig_obj[0] = args;
51750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51751 if (!SWIG_IsOK(res1)) {
51752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51753 }
51754 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51755 {
51756 PyThreadState* __tstate = wxPyBeginAllowThreads();
51757 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51758 wxPyEndAllowThreads(__tstate);
51759 if (PyErr_Occurred()) SWIG_fail;
51760 }
51761 {
51762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51763 }
51764 return resultobj;
51765 fail:
51766 return NULL;
51767 }
51768
51769
51770 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51771 PyObject *resultobj = 0;
51772 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51773 bool arg2 ;
51774 void *argp1 = 0 ;
51775 int res1 = 0 ;
51776 bool val2 ;
51777 int ecode2 = 0 ;
51778 PyObject * obj0 = 0 ;
51779 PyObject * obj1 = 0 ;
51780 char * kwnames[] = {
51781 (char *) "self",(char *) "d", NULL
51782 };
51783
51784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51786 if (!SWIG_IsOK(res1)) {
51787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51788 }
51789 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51790 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51791 if (!SWIG_IsOK(ecode2)) {
51792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51793 }
51794 arg2 = static_cast< bool >(val2);
51795 {
51796 PyThreadState* __tstate = wxPyBeginAllowThreads();
51797 (arg1)->SetDone(arg2);
51798 wxPyEndAllowThreads(__tstate);
51799 if (PyErr_Occurred()) SWIG_fail;
51800 }
51801 resultobj = SWIG_Py_Void();
51802 return resultobj;
51803 fail:
51804 return NULL;
51805 }
51806
51807
51808 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51809 PyObject *resultobj = 0;
51810 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51811 wxRelationship result;
51812 void *argp1 = 0 ;
51813 int res1 = 0 ;
51814 PyObject *swig_obj[1] ;
51815
51816 if (!args) SWIG_fail;
51817 swig_obj[0] = args;
51818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51819 if (!SWIG_IsOK(res1)) {
51820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51821 }
51822 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51823 {
51824 PyThreadState* __tstate = wxPyBeginAllowThreads();
51825 result = (wxRelationship)(arg1)->GetRelationship();
51826 wxPyEndAllowThreads(__tstate);
51827 if (PyErr_Occurred()) SWIG_fail;
51828 }
51829 resultobj = SWIG_From_int(static_cast< int >(result));
51830 return resultobj;
51831 fail:
51832 return NULL;
51833 }
51834
51835
51836 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51837 PyObject *resultobj = 0;
51838 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51839 wxRelationship arg2 ;
51840 void *argp1 = 0 ;
51841 int res1 = 0 ;
51842 int val2 ;
51843 int ecode2 = 0 ;
51844 PyObject * obj0 = 0 ;
51845 PyObject * obj1 = 0 ;
51846 char * kwnames[] = {
51847 (char *) "self",(char *) "r", NULL
51848 };
51849
51850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51852 if (!SWIG_IsOK(res1)) {
51853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51854 }
51855 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51856 ecode2 = SWIG_AsVal_int(obj1, &val2);
51857 if (!SWIG_IsOK(ecode2)) {
51858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51859 }
51860 arg2 = static_cast< wxRelationship >(val2);
51861 {
51862 PyThreadState* __tstate = wxPyBeginAllowThreads();
51863 (arg1)->SetRelationship(arg2);
51864 wxPyEndAllowThreads(__tstate);
51865 if (PyErr_Occurred()) SWIG_fail;
51866 }
51867 resultobj = SWIG_Py_Void();
51868 return resultobj;
51869 fail:
51870 return NULL;
51871 }
51872
51873
51874 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51875 PyObject *resultobj = 0;
51876 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51877 wxWindow *arg2 = (wxWindow *) 0 ;
51878 bool result;
51879 void *argp1 = 0 ;
51880 int res1 = 0 ;
51881 void *argp2 = 0 ;
51882 int res2 = 0 ;
51883 PyObject * obj0 = 0 ;
51884 PyObject * obj1 = 0 ;
51885 char * kwnames[] = {
51886 (char *) "self",(char *) "otherW", NULL
51887 };
51888
51889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
51890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51891 if (!SWIG_IsOK(res1)) {
51892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51893 }
51894 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51895 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51896 if (!SWIG_IsOK(res2)) {
51897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51898 }
51899 arg2 = reinterpret_cast< wxWindow * >(argp2);
51900 {
51901 PyThreadState* __tstate = wxPyBeginAllowThreads();
51902 result = (bool)(arg1)->ResetIfWin(arg2);
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_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51916 PyObject *resultobj = 0;
51917 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51918 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
51919 wxWindow *arg3 = (wxWindow *) 0 ;
51920 bool result;
51921 void *argp1 = 0 ;
51922 int res1 = 0 ;
51923 void *argp2 = 0 ;
51924 int res2 = 0 ;
51925 void *argp3 = 0 ;
51926 int res3 = 0 ;
51927 PyObject * obj0 = 0 ;
51928 PyObject * obj1 = 0 ;
51929 PyObject * obj2 = 0 ;
51930 char * kwnames[] = {
51931 (char *) "self",(char *) "constraints",(char *) "win", NULL
51932 };
51933
51934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51936 if (!SWIG_IsOK(res1)) {
51937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51938 }
51939 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51940 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51941 if (!SWIG_IsOK(res2)) {
51942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
51943 }
51944 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
51945 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51946 if (!SWIG_IsOK(res3)) {
51947 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
51948 }
51949 arg3 = reinterpret_cast< wxWindow * >(argp3);
51950 {
51951 PyThreadState* __tstate = wxPyBeginAllowThreads();
51952 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
51953 wxPyEndAllowThreads(__tstate);
51954 if (PyErr_Occurred()) SWIG_fail;
51955 }
51956 {
51957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51958 }
51959 return resultobj;
51960 fail:
51961 return NULL;
51962 }
51963
51964
51965 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51966 PyObject *resultobj = 0;
51967 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51968 wxEdge arg2 ;
51969 wxWindow *arg3 = (wxWindow *) 0 ;
51970 wxWindow *arg4 = (wxWindow *) 0 ;
51971 int result;
51972 void *argp1 = 0 ;
51973 int res1 = 0 ;
51974 int val2 ;
51975 int ecode2 = 0 ;
51976 void *argp3 = 0 ;
51977 int res3 = 0 ;
51978 void *argp4 = 0 ;
51979 int res4 = 0 ;
51980 PyObject * obj0 = 0 ;
51981 PyObject * obj1 = 0 ;
51982 PyObject * obj2 = 0 ;
51983 PyObject * obj3 = 0 ;
51984 char * kwnames[] = {
51985 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
51986 };
51987
51988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51990 if (!SWIG_IsOK(res1)) {
51991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51992 }
51993 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51994 ecode2 = SWIG_AsVal_int(obj1, &val2);
51995 if (!SWIG_IsOK(ecode2)) {
51996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51997 }
51998 arg2 = static_cast< wxEdge >(val2);
51999 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52000 if (!SWIG_IsOK(res3)) {
52001 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52002 }
52003 arg3 = reinterpret_cast< wxWindow * >(argp3);
52004 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52005 if (!SWIG_IsOK(res4)) {
52006 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52007 }
52008 arg4 = reinterpret_cast< wxWindow * >(argp4);
52009 {
52010 PyThreadState* __tstate = wxPyBeginAllowThreads();
52011 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52012 wxPyEndAllowThreads(__tstate);
52013 if (PyErr_Occurred()) SWIG_fail;
52014 }
52015 resultobj = SWIG_From_int(static_cast< int >(result));
52016 return resultobj;
52017 fail:
52018 return NULL;
52019 }
52020
52021
52022 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52023 PyObject *obj;
52024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52025 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52026 return SWIG_Py_Void();
52027 }
52028
52029 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52030 PyObject *resultobj = 0;
52031 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52032 wxIndividualLayoutConstraint *result = 0 ;
52033 void *argp1 = 0 ;
52034 int res1 = 0 ;
52035 PyObject *swig_obj[1] ;
52036
52037 if (!args) SWIG_fail;
52038 swig_obj[0] = args;
52039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52040 if (!SWIG_IsOK(res1)) {
52041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52042 }
52043 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52044 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52046 return resultobj;
52047 fail:
52048 return NULL;
52049 }
52050
52051
52052 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52053 PyObject *resultobj = 0;
52054 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52055 wxIndividualLayoutConstraint *result = 0 ;
52056 void *argp1 = 0 ;
52057 int res1 = 0 ;
52058 PyObject *swig_obj[1] ;
52059
52060 if (!args) SWIG_fail;
52061 swig_obj[0] = args;
52062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52063 if (!SWIG_IsOK(res1)) {
52064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52065 }
52066 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52067 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52069 return resultobj;
52070 fail:
52071 return NULL;
52072 }
52073
52074
52075 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52076 PyObject *resultobj = 0;
52077 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52078 wxIndividualLayoutConstraint *result = 0 ;
52079 void *argp1 = 0 ;
52080 int res1 = 0 ;
52081 PyObject *swig_obj[1] ;
52082
52083 if (!args) SWIG_fail;
52084 swig_obj[0] = args;
52085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52086 if (!SWIG_IsOK(res1)) {
52087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52088 }
52089 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52090 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52092 return resultobj;
52093 fail:
52094 return NULL;
52095 }
52096
52097
52098 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52099 PyObject *resultobj = 0;
52100 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52101 wxIndividualLayoutConstraint *result = 0 ;
52102 void *argp1 = 0 ;
52103 int res1 = 0 ;
52104 PyObject *swig_obj[1] ;
52105
52106 if (!args) SWIG_fail;
52107 swig_obj[0] = args;
52108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52109 if (!SWIG_IsOK(res1)) {
52110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52111 }
52112 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52113 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52115 return resultobj;
52116 fail:
52117 return NULL;
52118 }
52119
52120
52121 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52122 PyObject *resultobj = 0;
52123 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52124 wxIndividualLayoutConstraint *result = 0 ;
52125 void *argp1 = 0 ;
52126 int res1 = 0 ;
52127 PyObject *swig_obj[1] ;
52128
52129 if (!args) SWIG_fail;
52130 swig_obj[0] = args;
52131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52132 if (!SWIG_IsOK(res1)) {
52133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52134 }
52135 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52136 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52138 return resultobj;
52139 fail:
52140 return NULL;
52141 }
52142
52143
52144 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52145 PyObject *resultobj = 0;
52146 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52147 wxIndividualLayoutConstraint *result = 0 ;
52148 void *argp1 = 0 ;
52149 int res1 = 0 ;
52150 PyObject *swig_obj[1] ;
52151
52152 if (!args) SWIG_fail;
52153 swig_obj[0] = args;
52154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52155 if (!SWIG_IsOK(res1)) {
52156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52157 }
52158 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52159 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52161 return resultobj;
52162 fail:
52163 return NULL;
52164 }
52165
52166
52167 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52168 PyObject *resultobj = 0;
52169 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52170 wxIndividualLayoutConstraint *result = 0 ;
52171 void *argp1 = 0 ;
52172 int res1 = 0 ;
52173 PyObject *swig_obj[1] ;
52174
52175 if (!args) SWIG_fail;
52176 swig_obj[0] = args;
52177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52178 if (!SWIG_IsOK(res1)) {
52179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52180 }
52181 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52182 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52184 return resultobj;
52185 fail:
52186 return NULL;
52187 }
52188
52189
52190 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52191 PyObject *resultobj = 0;
52192 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52193 wxIndividualLayoutConstraint *result = 0 ;
52194 void *argp1 = 0 ;
52195 int res1 = 0 ;
52196 PyObject *swig_obj[1] ;
52197
52198 if (!args) SWIG_fail;
52199 swig_obj[0] = args;
52200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52201 if (!SWIG_IsOK(res1)) {
52202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52203 }
52204 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52205 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52207 return resultobj;
52208 fail:
52209 return NULL;
52210 }
52211
52212
52213 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52214 PyObject *resultobj = 0;
52215 wxLayoutConstraints *result = 0 ;
52216
52217 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52218 {
52219 PyThreadState* __tstate = wxPyBeginAllowThreads();
52220 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52221 wxPyEndAllowThreads(__tstate);
52222 if (PyErr_Occurred()) SWIG_fail;
52223 }
52224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52225 return resultobj;
52226 fail:
52227 return NULL;
52228 }
52229
52230
52231 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52232 PyObject *resultobj = 0;
52233 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52234 void *argp1 = 0 ;
52235 int res1 = 0 ;
52236 PyObject *swig_obj[1] ;
52237
52238 if (!args) SWIG_fail;
52239 swig_obj[0] = args;
52240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52241 if (!SWIG_IsOK(res1)) {
52242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52243 }
52244 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52245 {
52246 PyThreadState* __tstate = wxPyBeginAllowThreads();
52247 delete arg1;
52248
52249 wxPyEndAllowThreads(__tstate);
52250 if (PyErr_Occurred()) SWIG_fail;
52251 }
52252 resultobj = SWIG_Py_Void();
52253 return resultobj;
52254 fail:
52255 return NULL;
52256 }
52257
52258
52259 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52260 PyObject *resultobj = 0;
52261 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52262 wxWindow *arg2 = (wxWindow *) 0 ;
52263 int *arg3 = (int *) 0 ;
52264 bool result;
52265 void *argp1 = 0 ;
52266 int res1 = 0 ;
52267 void *argp2 = 0 ;
52268 int res2 = 0 ;
52269 int temp3 ;
52270 int res3 = SWIG_TMPOBJ ;
52271 PyObject * obj0 = 0 ;
52272 PyObject * obj1 = 0 ;
52273 char * kwnames[] = {
52274 (char *) "self",(char *) "win", NULL
52275 };
52276
52277 arg3 = &temp3;
52278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52280 if (!SWIG_IsOK(res1)) {
52281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52282 }
52283 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52284 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52285 if (!SWIG_IsOK(res2)) {
52286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52287 }
52288 arg2 = reinterpret_cast< wxWindow * >(argp2);
52289 {
52290 PyThreadState* __tstate = wxPyBeginAllowThreads();
52291 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52292 wxPyEndAllowThreads(__tstate);
52293 if (PyErr_Occurred()) SWIG_fail;
52294 }
52295 {
52296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52297 }
52298 if (SWIG_IsTmpObj(res3)) {
52299 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52300 } else {
52301 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52302 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52303 }
52304 return resultobj;
52305 fail:
52306 return NULL;
52307 }
52308
52309
52310 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52311 PyObject *resultobj = 0;
52312 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52313 bool result;
52314 void *argp1 = 0 ;
52315 int res1 = 0 ;
52316 PyObject *swig_obj[1] ;
52317
52318 if (!args) SWIG_fail;
52319 swig_obj[0] = args;
52320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52321 if (!SWIG_IsOK(res1)) {
52322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52323 }
52324 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52325 {
52326 PyThreadState* __tstate = wxPyBeginAllowThreads();
52327 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52328 wxPyEndAllowThreads(__tstate);
52329 if (PyErr_Occurred()) SWIG_fail;
52330 }
52331 {
52332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52333 }
52334 return resultobj;
52335 fail:
52336 return NULL;
52337 }
52338
52339
52340 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52341 PyObject *obj;
52342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52343 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52344 return SWIG_Py_Void();
52345 }
52346
52347 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52348 return SWIG_Python_InitShadowInstance(args);
52349 }
52350
52351 static PyMethodDef SwigMethods[] = {
52352 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52353 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
52354 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52355 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52356 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52357 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52358 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52359 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52360 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52361 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52362 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52363 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52364 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52365 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52366 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52367 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52368 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52369 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52370 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52371 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52372 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52373 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52374 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52375 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52376 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52377 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52378 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52379 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52380 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52381 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52382 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52383 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52384 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52385 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52386 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52387 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52388 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52389 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52390 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52391 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52392 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52393 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52394 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52395 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52396 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52397 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52398 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52399 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52400 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52401 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52402 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52403 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52404 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52405 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52406 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52407 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52408 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52409 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52410 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52411 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52412 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52413 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52414 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52415 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52416 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52417 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52418 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52419 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52420 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52421 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52422 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52423 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52424 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52425 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52426 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52427 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52428 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52429 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52430 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52431 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52432 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52433 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52434 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52435 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52436 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52437 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52438 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52439 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52440 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52441 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52442 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52443 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52444 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52445 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52446 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52447 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52448 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52449 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52450 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52451 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52452 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52453 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52454 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52455 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52456 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52457 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52458 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52459 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52460 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52461 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52462 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52463 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52464 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52465 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52466 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52467 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52468 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52469 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52470 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52471 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52472 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52473 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52474 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52475 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52476 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52477 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52478 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52479 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52480 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52481 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52482 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52483 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52484 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52485 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52486 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52487 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52488 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52489 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52490 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52491 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52492 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52493 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52494 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52495 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52496 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52497 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52498 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52499 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52500 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52501 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52502 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52503 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52504 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52505 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52506 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52507 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52508 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52509 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52510 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52511 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52512 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52513 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52514 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52515 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52516 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52517 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52518 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52519 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52520 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52521 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52522 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52523 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52524 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52525 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52526 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52527 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52528 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52529 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52530 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52531 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52532 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52533 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52534 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52535 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52536 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52537 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52538 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52539 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52540 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52541 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52542 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52543 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52544 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52545 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52546 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52547 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52548 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52549 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52550 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52551 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52552 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52553 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52554 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52555 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52556 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52557 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52558 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52559 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52560 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52561 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52562 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52563 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52564 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52565 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52566 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52567 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52568 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52569 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52570 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52571 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52572 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52573 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52574 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52575 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52576 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52577 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52578 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52579 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52580 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52581 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52582 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52583 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52584 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52585 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52586 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52587 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52588 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52589 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52590 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52591 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52592 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52593 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52594 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52596 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52597 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52598 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52599 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52600 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52601 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52602 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52603 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52604 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52605 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52606 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52607 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52608 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52609 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52610 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52611 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52612 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52613 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52614 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52615 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52616 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52617 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52618 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52619 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52621 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52623 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52624 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52627 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52628 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52629 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52630 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52631 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52632 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52633 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52634 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52636 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52637 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52638 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52639 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52640 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52641 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52642 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52643 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52644 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52645 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52646 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52647 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52648 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52649 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52651 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52653 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52655 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52656 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52657 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52658 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52659 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52660 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52661 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52662 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52663 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52664 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52665 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52666 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52667 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52668 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52669 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52670 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52671 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52672 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52673 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52674 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52675 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52676 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52677 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52678 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52679 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52683 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52684 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52685 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52686 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52692 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52693 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52694 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52695 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52696 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52697 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52698 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52699 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52700 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52701 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52702 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52703 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52704 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52705 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52706 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52707 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52708 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52709 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52710 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52711 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52712 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52713 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52714 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52715 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52716 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52717 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52718 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52719 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52720 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52721 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52722 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52723 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52724 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52725 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52726 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52727 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52728 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52729 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52730 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52731 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52732 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52733 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52734 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52735 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52736 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52737 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52738 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52739 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52740 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52741 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52744 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52746 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52747 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52748 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52749 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52750 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52751 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52752 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52753 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52754 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52755 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52756 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52757 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52758 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52760 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52762 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52763 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52764 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52765 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52766 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52767 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52768 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52770 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52771 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52772 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52773 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52774 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52775 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52776 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52777 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52778 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52779 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52781 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52783 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52784 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52785 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52787 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52789 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52790 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52792 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52793 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52794 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52796 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52797 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52798 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52799 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52800 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52802 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52803 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52804 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52806 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52807 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52809 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52810 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52813 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52814 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52816 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52822 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52823 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52824 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52825 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52826 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52827 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52828 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52829 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52830 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52831 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52832 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52833 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52834 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52835 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52836 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52837 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52838 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52839 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52840 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52841 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52842 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52843 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52844 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52845 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52847 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52848 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52849 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52850 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52851 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52852 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52853 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52854 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52855 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52856 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52857 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52858 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52859 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52860 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52861 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52862 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52863 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52864 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52865 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52866 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52867 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52868 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52869 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52870 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52871 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52872 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52873 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52874 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52875 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52876 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52877 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52878 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
52880 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
52881 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
52883 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
52884 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
52885 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
52886 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
52888 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
52889 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
52890 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
52891 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
52892 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
52893 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
52894 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
52895 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
52896 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
52897 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
52898 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
52899 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
52900 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
52901 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
52902 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
52903 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
52904 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
52905 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
52906 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
52907 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
52908 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
52909 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
52910 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
52911 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
52912 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
52913 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
52914 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
52915 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
52916 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
52917 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
52918 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
52919 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
52920 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
52921 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
52922 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
52923 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
52924 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
52926 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
52927 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52929 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
52930 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
52931 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
52932 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
52933 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
52934 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
52935 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
52937 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
52938 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52940 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
52941 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
52942 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
52944 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
52945 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
52947 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
52948 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
52950 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
52951 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
52952 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
52954 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
52956 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
52957 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
52959 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
52960 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
52961 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
52963 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
52964 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
52965 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52966 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
52967 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
52968 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
52970 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
52971 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
52972 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
52973 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
52974 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52975 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
52976 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
52977 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
52979 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
52981 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
52982 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
52983 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
52986 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
52987 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
52988 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52989 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
52990 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
52991 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
52992 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
52994 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
52995 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
52996 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
52997 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
52998 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
52999 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53000 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53001 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53002 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53003 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53004 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53005 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53006 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53007 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53008 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53009 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53014 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53016 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53018 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53019 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53020 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53021 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53022 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53023 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53025 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53026 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53027 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53028 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53029 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53030 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53033 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53034 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53035 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53037 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53038 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53039 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53040 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53041 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53042 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53044 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53046 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53049 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53050 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53051 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53052 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53054 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53055 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53056 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53058 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53059 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53060 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53062 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53064 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53065 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53066 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53067 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53068 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53070 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53072 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53073 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53075 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53077 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53078 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53079 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53081 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53083 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53084 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53085 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53087 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53089 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53090 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53091 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53092 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53094 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53096 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53098 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53100 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53101 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53103 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53104 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53105 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53106 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53107 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53108 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53109 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53110 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53112 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53114 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53116 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53118 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53120 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53122 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53123 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53124 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53125 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53126 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53127 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53133 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53134 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53135 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53136 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53137 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53138 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53139 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53141 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53143 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53144 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53146 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53147 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53148 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53149 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53151 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53152 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53153 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53154 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53156 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53157 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53159 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53160 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53161 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53163 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53165 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53166 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53167 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53168 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53169 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53171 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53172 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53173 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53174 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53176 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53177 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53178 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53179 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53180 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53181 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53182 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53183 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53184 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53185 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53187 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53190 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53191 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53192 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53194 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53195 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53196 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53198 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53200 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53201 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53203 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53204 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53205 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53211 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53212 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53216 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53217 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53218 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53219 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53220 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53221 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53222 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53223 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53224 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53225 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53226 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53227 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53228 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53229 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53230 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53231 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53232 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53233 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53236 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53237 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53242 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53243 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53246 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53247 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53248 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53249 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53252 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53253 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53254 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53256 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53258 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53259 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53260 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53262 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53264 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53265 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53266 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53269 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53270 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53271 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53272 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53273 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53274 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53275 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53281 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53282 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53283 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53284 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53290 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53296 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53297 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53298 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53299 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53300 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53302 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53303 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53310 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53311 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53312 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53313 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53314 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53315 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53318 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53319 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53320 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53321 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53323 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53324 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53328 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53334 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53335 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53336 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53337 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53339 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53340 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53341 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53342 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53345 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53347 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53348 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53349 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53358 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53362 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53364 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53366 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53374 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53375 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53376 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53377 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53380 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53383 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53385 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53388 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53390 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53391 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53394 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53396 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53397 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53398 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53399 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53400 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53405 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53406 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53407 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53409 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53410 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53411 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53413 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53415 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53416 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53417 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53419 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53420 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53423 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53430 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53437 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53442 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53445 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53448 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53449 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53462 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53464 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53466 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53467 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53469 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53471 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53472 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53474 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53475 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53476 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53480 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53499 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53500 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53502 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53504 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53505 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53506 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53508 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53509 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53512 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53513 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53515 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53516 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53518 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53521 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53522 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53524 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53526 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53528 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53529 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53531 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53532 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53535 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53537 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53539 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53541 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53544 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53546 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53547 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53548 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53550 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53551 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53552 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53554 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53557 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53559 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53560 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53564 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53566 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53568 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53569 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53571 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53575 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53577 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53579 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53580 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53581 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53582 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53586 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53587 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53588 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53589 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53591 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53592 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53593 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53597 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53598 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53599 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53600 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53601 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53603 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53605 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53607 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53608 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53610 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53612 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53615 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53616 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53617 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53619 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53620 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53621 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53635 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53636 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53637 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53638 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53639 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53640 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53646 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53647 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53651 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53652 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53654 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53655 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53657 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53659 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53660 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53662 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53663 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53664 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53670 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53671 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53672 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53673 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53674 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53675 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53682 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53684 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53685 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53686 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53687 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53688 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53689 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53691 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53695 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53696 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53697 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53698 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53699 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53700 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53701 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53703 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53704 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53705 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53711 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53712 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53713 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53715 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53716 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53717 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53723 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53724 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53725 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53726 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53727 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53731 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53732 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53737 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53738 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53740 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53741 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53746 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53748 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53749 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53750 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53751 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53752 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53757 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53758 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53767 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53768 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53769 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53770 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53773 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53775 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53776 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53777 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53778 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53780 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53785 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53786 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53787 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53788 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53789 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53790 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53791 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53792 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53793 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53794 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53795 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53797 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53798 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53799 { NULL, NULL, 0, NULL }
53800 };
53801
53802
53803 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53804
53805 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53806 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53807 }
53808 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53809 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53810 }
53811 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53812 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53813 }
53814 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53815 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53816 }
53817 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53818 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53819 }
53820 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53821 return (void *)((wxSizer *) ((wxGridSizer *) x));
53822 }
53823 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53824 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53825 }
53826 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53827 return (void *)((wxSizer *) ((wxPySizer *) x));
53828 }
53829 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53830 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53831 }
53832 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53833 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53834 }
53835 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53836 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53837 }
53838 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53839 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53840 }
53841 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53842 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53843 }
53844 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53845 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53846 }
53847 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53848 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53849 }
53850 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53851 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53852 }
53853 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53854 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53855 }
53856 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53857 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53858 }
53859 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53860 return (void *)((wxEvent *) ((wxPyEvent *) x));
53861 }
53862 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53863 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53864 }
53865 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53866 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53867 }
53868 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53869 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53870 }
53871 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53872 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53873 }
53874 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53875 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53876 }
53877 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53878 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
53879 }
53880 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
53881 return (void *)((wxEvent *) ((wxActivateEvent *) x));
53882 }
53883 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
53884 return (void *)((wxEvent *) ((wxSizeEvent *) x));
53885 }
53886 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
53887 return (void *)((wxEvent *) ((wxMoveEvent *) x));
53888 }
53889 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
53890 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
53891 }
53892 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
53893 return (void *)((wxEvent *) ((wxPaintEvent *) x));
53894 }
53895 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
53896 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
53897 }
53898 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
53899 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
53900 }
53901 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
53902 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
53903 }
53904 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
53905 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
53906 }
53907 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
53908 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53909 }
53910 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
53911 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
53912 }
53913 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
53914 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
53915 }
53916 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
53917 return (void *)((wxEvent *) ((wxFocusEvent *) x));
53918 }
53919 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
53920 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
53921 }
53922 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
53923 return (void *)((wxEvent *) ((wxShowEvent *) x));
53924 }
53925 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
53926 return (void *)((wxEvent *) ((wxCommandEvent *) x));
53927 }
53928 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
53929 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
53930 }
53931 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
53932 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
53933 }
53934 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
53935 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
53936 }
53937 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
53938 return (void *)((wxEvent *) ((wxKeyEvent *) x));
53939 }
53940 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
53941 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
53942 }
53943 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
53944 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
53945 }
53946 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
53947 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
53948 }
53949 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
53950 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
53951 }
53952 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
53953 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
53954 }
53955 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
53956 return (void *)((wxControl *) ((wxControlWithItems *) x));
53957 }
53958 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
53959 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
53960 }
53961 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
53962 return (void *)((wxEvtHandler *) ((wxWindow *) x));
53963 }
53964 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
53965 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
53966 }
53967 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
53968 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
53969 }
53970 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
53971 return (void *)((wxEvtHandler *) ((wxValidator *) x));
53972 }
53973 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
53974 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
53975 }
53976 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
53977 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
53978 }
53979 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
53980 return (void *)((wxEvtHandler *) ((wxMenu *) x));
53981 }
53982 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
53983 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
53984 }
53985 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
53986 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
53987 }
53988 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
53989 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
53990 }
53991 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
53992 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
53993 }
53994 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
53995 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
53996 }
53997 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
53998 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
53999 }
54000 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54001 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54002 }
54003 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54004 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54005 }
54006 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54007 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54008 }
54009 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54010 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54011 }
54012 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54013 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54014 }
54015 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54016 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54017 }
54018 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54019 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54020 }
54021 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54022 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54023 }
54024 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54025 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54026 }
54027 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54028 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54029 }
54030 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54031 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54032 }
54033 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54034 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54035 }
54036 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54037 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54038 }
54039 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54040 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54041 }
54042 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54043 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54044 }
54045 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54046 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54047 }
54048 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54049 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54050 }
54051 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54052 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54053 }
54054 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54055 return (void *)((wxObject *) ((wxSizerItem *) x));
54056 }
54057 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54058 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54059 }
54060 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54061 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54062 }
54063 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54064 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54065 }
54066 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54067 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54068 }
54069 static void *_p_wxSizerTo_p_wxObject(void *x) {
54070 return (void *)((wxObject *) ((wxSizer *) x));
54071 }
54072 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54073 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54074 }
54075 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54076 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54077 }
54078 static void *_p_wxEventTo_p_wxObject(void *x) {
54079 return (void *)((wxObject *) ((wxEvent *) x));
54080 }
54081 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54082 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54083 }
54084 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54085 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54086 }
54087 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54088 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54089 }
54090 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54091 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54092 }
54093 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54094 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54095 }
54096 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54097 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54098 }
54099 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54100 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54101 }
54102 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54103 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54104 }
54105 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54106 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54107 }
54108 static void *_p_wxControlTo_p_wxObject(void *x) {
54109 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54110 }
54111 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54112 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54113 }
54114 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54115 return (void *)((wxObject *) ((wxFSFile *) x));
54116 }
54117 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54118 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54119 }
54120 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54121 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54122 }
54123 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54124 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54125 }
54126 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54127 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54128 }
54129 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54130 return (void *)((wxObject *) ((wxMenuItem *) x));
54131 }
54132 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54133 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54134 }
54135 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54136 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54137 }
54138 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54139 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54140 }
54141 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54142 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54143 }
54144 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54145 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54146 }
54147 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54148 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54149 }
54150 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54151 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54152 }
54153 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54154 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54155 }
54156 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54157 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54158 }
54159 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54160 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54161 }
54162 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54163 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54164 }
54165 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54166 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54167 }
54168 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54169 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54170 }
54171 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54172 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54173 }
54174 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54175 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54176 }
54177 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54178 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54179 }
54180 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54181 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54182 }
54183 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54184 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54185 }
54186 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54187 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54188 }
54189 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54190 return (void *)((wxObject *) ((wxImageHandler *) x));
54191 }
54192 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54193 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54194 }
54195 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54196 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54197 }
54198 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54199 return (void *)((wxObject *) ((wxEvtHandler *) x));
54200 }
54201 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54202 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54203 }
54204 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54205 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54206 }
54207 static void *_p_wxImageTo_p_wxObject(void *x) {
54208 return (void *)((wxObject *) ((wxImage *) x));
54209 }
54210 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54211 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54212 }
54213 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54214 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54215 }
54216 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54217 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54218 }
54219 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54220 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54221 }
54222 static void *_p_wxWindowTo_p_wxObject(void *x) {
54223 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54224 }
54225 static void *_p_wxMenuTo_p_wxObject(void *x) {
54226 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54227 }
54228 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54229 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54230 }
54231 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54232 return (void *)((wxObject *) ((wxFileSystem *) x));
54233 }
54234 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54235 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54236 }
54237 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54238 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54239 }
54240 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54241 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54242 }
54243 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54244 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54245 }
54246 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54247 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54248 }
54249 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54250 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54251 }
54252 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54253 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54254 }
54255 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54256 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54257 }
54258 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54259 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54260 }
54261 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54262 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54263 }
54264 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54265 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54266 }
54267 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54268 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54269 }
54270 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54271 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54272 }
54273 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54274 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54275 }
54276 static void *_p_wxControlTo_p_wxWindow(void *x) {
54277 return (void *)((wxWindow *) ((wxControl *) x));
54278 }
54279 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54280 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54281 }
54282 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54283 return (void *)((wxWindow *) ((wxMenuBar *) x));
54284 }
54285 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54286 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54287 }
54288 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54289 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54290 }
54291 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54292 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54293 }
54294 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54295 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54296 }
54297 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54298 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54299 }
54300 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54301 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54302 }
54303 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54304 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54305 }
54306 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54307 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54308 }
54309 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54310 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54311 }
54312 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54313 return (void *)((wxValidator *) ((wxPyValidator *) x));
54314 }
54315 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54316 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54317 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};
54318 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54319 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54320 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54321 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54322 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54323 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54324 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54325 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54326 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54327 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54328 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54329 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54330 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54331 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54332 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54333 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54334 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54335 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54336 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54337 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54338 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54339 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54340 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54341 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54342 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54343 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54344 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54345 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54346 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54347 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54348 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54349 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54350 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54351 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54352 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54353 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54354 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54355 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54356 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54357 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54358 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54359 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54360 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54361 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54362 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54363 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54364 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54365 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54366 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54367 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54368 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54369 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54370 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54371 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54372 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54373 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54374 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54375 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54376 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54377 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54378 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54379 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54380 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54381 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54382 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54383 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54384 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54385 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54386 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54387 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54388 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54389 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54390 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54391 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54392 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54393 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54394 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54395 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54396 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54397 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54398 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54399 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54400 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54401 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54402 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54403 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54404 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54405 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54406 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54407 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54408 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54409 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54410 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54411 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54412 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54413 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54414 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54415 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54416 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54417 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54418 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54419 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54420 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54421 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54422 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54423 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54424 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54425 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54426 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54427 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54428 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54429 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54430 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54431 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54432 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54433 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54434 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54435 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54436 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54437 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54438 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54439 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54440 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54441 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54442 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54443 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54444
54445 static swig_type_info *swig_type_initial[] = {
54446 &_swigt__p_buffer,
54447 &_swigt__p_char,
54448 &_swigt__p_form_ops_t,
54449 &_swigt__p_int,
54450 &_swigt__p_long,
54451 &_swigt__p_unsigned_char,
54452 &_swigt__p_unsigned_int,
54453 &_swigt__p_unsigned_long,
54454 &_swigt__p_wxANIHandler,
54455 &_swigt__p_wxAcceleratorEntry,
54456 &_swigt__p_wxAcceleratorTable,
54457 &_swigt__p_wxActivateEvent,
54458 &_swigt__p_wxAppTraits,
54459 &_swigt__p_wxArrayString,
54460 &_swigt__p_wxBMPHandler,
54461 &_swigt__p_wxBitmap,
54462 &_swigt__p_wxBoxSizer,
54463 &_swigt__p_wxButton,
54464 &_swigt__p_wxCURHandler,
54465 &_swigt__p_wxCaret,
54466 &_swigt__p_wxChildFocusEvent,
54467 &_swigt__p_wxCloseEvent,
54468 &_swigt__p_wxColour,
54469 &_swigt__p_wxCommandEvent,
54470 &_swigt__p_wxContextMenuEvent,
54471 &_swigt__p_wxControl,
54472 &_swigt__p_wxControlWithItems,
54473 &_swigt__p_wxCursor,
54474 &_swigt__p_wxDC,
54475 &_swigt__p_wxDateEvent,
54476 &_swigt__p_wxDateTime,
54477 &_swigt__p_wxDisplayChangedEvent,
54478 &_swigt__p_wxDropFilesEvent,
54479 &_swigt__p_wxDuplexMode,
54480 &_swigt__p_wxEraseEvent,
54481 &_swigt__p_wxEvent,
54482 &_swigt__p_wxEventLoop,
54483 &_swigt__p_wxEventLoopActivator,
54484 &_swigt__p_wxEvtHandler,
54485 &_swigt__p_wxFSFile,
54486 &_swigt__p_wxFileSystem,
54487 &_swigt__p_wxFileSystemHandler,
54488 &_swigt__p_wxFlexGridSizer,
54489 &_swigt__p_wxFocusEvent,
54490 &_swigt__p_wxFont,
54491 &_swigt__p_wxFrame,
54492 &_swigt__p_wxGBPosition,
54493 &_swigt__p_wxGBSizerItem,
54494 &_swigt__p_wxGBSpan,
54495 &_swigt__p_wxGIFHandler,
54496 &_swigt__p_wxGridBagSizer,
54497 &_swigt__p_wxGridSizer,
54498 &_swigt__p_wxICOHandler,
54499 &_swigt__p_wxIconizeEvent,
54500 &_swigt__p_wxIdleEvent,
54501 &_swigt__p_wxImage,
54502 &_swigt__p_wxImageHandler,
54503 &_swigt__p_wxImageHistogram,
54504 &_swigt__p_wxImage_HSVValue,
54505 &_swigt__p_wxImage_RGBValue,
54506 &_swigt__p_wxIndividualLayoutConstraint,
54507 &_swigt__p_wxInitDialogEvent,
54508 &_swigt__p_wxInputStream,
54509 &_swigt__p_wxInternetFSHandler,
54510 &_swigt__p_wxItemContainer,
54511 &_swigt__p_wxJPEGHandler,
54512 &_swigt__p_wxKeyEvent,
54513 &_swigt__p_wxLayoutConstraints,
54514 &_swigt__p_wxMaximizeEvent,
54515 &_swigt__p_wxMemoryFSHandler,
54516 &_swigt__p_wxMenu,
54517 &_swigt__p_wxMenuBar,
54518 &_swigt__p_wxMenuBarBase,
54519 &_swigt__p_wxMenuEvent,
54520 &_swigt__p_wxMenuItem,
54521 &_swigt__p_wxMouseCaptureChangedEvent,
54522 &_swigt__p_wxMouseEvent,
54523 &_swigt__p_wxMoveEvent,
54524 &_swigt__p_wxNavigationKeyEvent,
54525 &_swigt__p_wxNcPaintEvent,
54526 &_swigt__p_wxNotifyEvent,
54527 &_swigt__p_wxObject,
54528 &_swigt__p_wxOutputStream,
54529 &_swigt__p_wxPCXHandler,
54530 &_swigt__p_wxPNGHandler,
54531 &_swigt__p_wxPNMHandler,
54532 &_swigt__p_wxPaintEvent,
54533 &_swigt__p_wxPaletteChangedEvent,
54534 &_swigt__p_wxPaperSize,
54535 &_swigt__p_wxPoint,
54536 &_swigt__p_wxPoint2D,
54537 &_swigt__p_wxPropagateOnce,
54538 &_swigt__p_wxPropagationDisabler,
54539 &_swigt__p_wxPyApp,
54540 &_swigt__p_wxPyCommandEvent,
54541 &_swigt__p_wxPyDropTarget,
54542 &_swigt__p_wxPyEvent,
54543 &_swigt__p_wxPyFileSystemHandler,
54544 &_swigt__p_wxPyImageHandler,
54545 &_swigt__p_wxPyInputStream,
54546 &_swigt__p_wxPySizer,
54547 &_swigt__p_wxPyValidator,
54548 &_swigt__p_wxQuantize,
54549 &_swigt__p_wxQueryNewPaletteEvent,
54550 &_swigt__p_wxRealPoint,
54551 &_swigt__p_wxRect,
54552 &_swigt__p_wxRegion,
54553 &_swigt__p_wxScrollEvent,
54554 &_swigt__p_wxScrollWinEvent,
54555 &_swigt__p_wxSetCursorEvent,
54556 &_swigt__p_wxShowEvent,
54557 &_swigt__p_wxSize,
54558 &_swigt__p_wxSizeEvent,
54559 &_swigt__p_wxSizer,
54560 &_swigt__p_wxSizerItem,
54561 &_swigt__p_wxStaticBox,
54562 &_swigt__p_wxStaticBoxSizer,
54563 &_swigt__p_wxStdDialogButtonSizer,
54564 &_swigt__p_wxSysColourChangedEvent,
54565 &_swigt__p_wxTIFFHandler,
54566 &_swigt__p_wxToolTip,
54567 &_swigt__p_wxUpdateUIEvent,
54568 &_swigt__p_wxValidator,
54569 &_swigt__p_wxVisualAttributes,
54570 &_swigt__p_wxWindow,
54571 &_swigt__p_wxWindowCreateEvent,
54572 &_swigt__p_wxWindowDestroyEvent,
54573 &_swigt__p_wxXPMHandler,
54574 &_swigt__p_wxZipFSHandler,
54575 };
54576
54577 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54578 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54579 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54580 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54581 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54582 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54583 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54584 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54585 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54586 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54587 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54588 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54589 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54590 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54591 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}};
54592 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54593 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}};
54594 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54595 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}};
54596 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54597 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54598 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54599 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54600 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}};
54601 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54602 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}};
54603 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54604 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54605 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54606 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54607 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54608 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54609 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54610 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54611 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54612 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}};
54613 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54614 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54615 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}};
54616 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54617 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54618 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}};
54619 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}};
54620 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54621 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54622 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54623 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54624 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54625 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54626 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54627 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54628 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}};
54629 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}};
54630 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54631 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54632 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54633 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}};
54634 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54635 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54636 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54637 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54638 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54639 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54640 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54641 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}};
54642 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54643 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54644 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54645 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54646 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54647 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54648 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54649 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54650 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54651 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54652 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54653 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54654 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54655 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54656 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54657 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54658 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}};
54659 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54660 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54661 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54662 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54663 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54664 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54665 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54666 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54667 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54668 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54669 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54670 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54671 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54672 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54673 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54674 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54675 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54676 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54677 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54678 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54679 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54680 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54681 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54682 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54683 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54684 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54685 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54686 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54687 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54688 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54689 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54690 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}};
54691 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}};
54692 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54693 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54694 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54695 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54696 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54697 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54698 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54699 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}};
54700 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54701 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}};
54702 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54703 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54704 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54705 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54706
54707 static swig_cast_info *swig_cast_initial[] = {
54708 _swigc__p_buffer,
54709 _swigc__p_char,
54710 _swigc__p_form_ops_t,
54711 _swigc__p_int,
54712 _swigc__p_long,
54713 _swigc__p_unsigned_char,
54714 _swigc__p_unsigned_int,
54715 _swigc__p_unsigned_long,
54716 _swigc__p_wxANIHandler,
54717 _swigc__p_wxAcceleratorEntry,
54718 _swigc__p_wxAcceleratorTable,
54719 _swigc__p_wxActivateEvent,
54720 _swigc__p_wxAppTraits,
54721 _swigc__p_wxArrayString,
54722 _swigc__p_wxBMPHandler,
54723 _swigc__p_wxBitmap,
54724 _swigc__p_wxBoxSizer,
54725 _swigc__p_wxButton,
54726 _swigc__p_wxCURHandler,
54727 _swigc__p_wxCaret,
54728 _swigc__p_wxChildFocusEvent,
54729 _swigc__p_wxCloseEvent,
54730 _swigc__p_wxColour,
54731 _swigc__p_wxCommandEvent,
54732 _swigc__p_wxContextMenuEvent,
54733 _swigc__p_wxControl,
54734 _swigc__p_wxControlWithItems,
54735 _swigc__p_wxCursor,
54736 _swigc__p_wxDC,
54737 _swigc__p_wxDateEvent,
54738 _swigc__p_wxDateTime,
54739 _swigc__p_wxDisplayChangedEvent,
54740 _swigc__p_wxDropFilesEvent,
54741 _swigc__p_wxDuplexMode,
54742 _swigc__p_wxEraseEvent,
54743 _swigc__p_wxEvent,
54744 _swigc__p_wxEventLoop,
54745 _swigc__p_wxEventLoopActivator,
54746 _swigc__p_wxEvtHandler,
54747 _swigc__p_wxFSFile,
54748 _swigc__p_wxFileSystem,
54749 _swigc__p_wxFileSystemHandler,
54750 _swigc__p_wxFlexGridSizer,
54751 _swigc__p_wxFocusEvent,
54752 _swigc__p_wxFont,
54753 _swigc__p_wxFrame,
54754 _swigc__p_wxGBPosition,
54755 _swigc__p_wxGBSizerItem,
54756 _swigc__p_wxGBSpan,
54757 _swigc__p_wxGIFHandler,
54758 _swigc__p_wxGridBagSizer,
54759 _swigc__p_wxGridSizer,
54760 _swigc__p_wxICOHandler,
54761 _swigc__p_wxIconizeEvent,
54762 _swigc__p_wxIdleEvent,
54763 _swigc__p_wxImage,
54764 _swigc__p_wxImageHandler,
54765 _swigc__p_wxImageHistogram,
54766 _swigc__p_wxImage_HSVValue,
54767 _swigc__p_wxImage_RGBValue,
54768 _swigc__p_wxIndividualLayoutConstraint,
54769 _swigc__p_wxInitDialogEvent,
54770 _swigc__p_wxInputStream,
54771 _swigc__p_wxInternetFSHandler,
54772 _swigc__p_wxItemContainer,
54773 _swigc__p_wxJPEGHandler,
54774 _swigc__p_wxKeyEvent,
54775 _swigc__p_wxLayoutConstraints,
54776 _swigc__p_wxMaximizeEvent,
54777 _swigc__p_wxMemoryFSHandler,
54778 _swigc__p_wxMenu,
54779 _swigc__p_wxMenuBar,
54780 _swigc__p_wxMenuBarBase,
54781 _swigc__p_wxMenuEvent,
54782 _swigc__p_wxMenuItem,
54783 _swigc__p_wxMouseCaptureChangedEvent,
54784 _swigc__p_wxMouseEvent,
54785 _swigc__p_wxMoveEvent,
54786 _swigc__p_wxNavigationKeyEvent,
54787 _swigc__p_wxNcPaintEvent,
54788 _swigc__p_wxNotifyEvent,
54789 _swigc__p_wxObject,
54790 _swigc__p_wxOutputStream,
54791 _swigc__p_wxPCXHandler,
54792 _swigc__p_wxPNGHandler,
54793 _swigc__p_wxPNMHandler,
54794 _swigc__p_wxPaintEvent,
54795 _swigc__p_wxPaletteChangedEvent,
54796 _swigc__p_wxPaperSize,
54797 _swigc__p_wxPoint,
54798 _swigc__p_wxPoint2D,
54799 _swigc__p_wxPropagateOnce,
54800 _swigc__p_wxPropagationDisabler,
54801 _swigc__p_wxPyApp,
54802 _swigc__p_wxPyCommandEvent,
54803 _swigc__p_wxPyDropTarget,
54804 _swigc__p_wxPyEvent,
54805 _swigc__p_wxPyFileSystemHandler,
54806 _swigc__p_wxPyImageHandler,
54807 _swigc__p_wxPyInputStream,
54808 _swigc__p_wxPySizer,
54809 _swigc__p_wxPyValidator,
54810 _swigc__p_wxQuantize,
54811 _swigc__p_wxQueryNewPaletteEvent,
54812 _swigc__p_wxRealPoint,
54813 _swigc__p_wxRect,
54814 _swigc__p_wxRegion,
54815 _swigc__p_wxScrollEvent,
54816 _swigc__p_wxScrollWinEvent,
54817 _swigc__p_wxSetCursorEvent,
54818 _swigc__p_wxShowEvent,
54819 _swigc__p_wxSize,
54820 _swigc__p_wxSizeEvent,
54821 _swigc__p_wxSizer,
54822 _swigc__p_wxSizerItem,
54823 _swigc__p_wxStaticBox,
54824 _swigc__p_wxStaticBoxSizer,
54825 _swigc__p_wxStdDialogButtonSizer,
54826 _swigc__p_wxSysColourChangedEvent,
54827 _swigc__p_wxTIFFHandler,
54828 _swigc__p_wxToolTip,
54829 _swigc__p_wxUpdateUIEvent,
54830 _swigc__p_wxValidator,
54831 _swigc__p_wxVisualAttributes,
54832 _swigc__p_wxWindow,
54833 _swigc__p_wxWindowCreateEvent,
54834 _swigc__p_wxWindowDestroyEvent,
54835 _swigc__p_wxXPMHandler,
54836 _swigc__p_wxZipFSHandler,
54837 };
54838
54839
54840 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54841
54842 static swig_const_info swig_const_table[] = {
54843 {0, 0, 0, 0.0, 0, 0}};
54844
54845 #ifdef __cplusplus
54846 }
54847 #endif
54848 /* -----------------------------------------------------------------------------
54849 * Type initialization:
54850 * This problem is tough by the requirement that no dynamic
54851 * memory is used. Also, since swig_type_info structures store pointers to
54852 * swig_cast_info structures and swig_cast_info structures store pointers back
54853 * to swig_type_info structures, we need some lookup code at initialization.
54854 * The idea is that swig generates all the structures that are needed.
54855 * The runtime then collects these partially filled structures.
54856 * The SWIG_InitializeModule function takes these initial arrays out of
54857 * swig_module, and does all the lookup, filling in the swig_module.types
54858 * array with the correct data and linking the correct swig_cast_info
54859 * structures together.
54860 *
54861 * The generated swig_type_info structures are assigned staticly to an initial
54862 * array. We just loop though that array, and handle each type individually.
54863 * First we lookup if this type has been already loaded, and if so, use the
54864 * loaded structure instead of the generated one. Then we have to fill in the
54865 * cast linked list. The cast data is initially stored in something like a
54866 * two-dimensional array. Each row corresponds to a type (there are the same
54867 * number of rows as there are in the swig_type_initial array). Each entry in
54868 * a column is one of the swig_cast_info structures for that type.
54869 * The cast_initial array is actually an array of arrays, because each row has
54870 * a variable number of columns. So to actually build the cast linked list,
54871 * we find the array of casts associated with the type, and loop through it
54872 * adding the casts to the list. The one last trick we need to do is making
54873 * sure the type pointer in the swig_cast_info struct is correct.
54874 *
54875 * First off, we lookup the cast->type name to see if it is already loaded.
54876 * There are three cases to handle:
54877 * 1) If the cast->type has already been loaded AND the type we are adding
54878 * casting info to has not been loaded (it is in this module), THEN we
54879 * replace the cast->type pointer with the type pointer that has already
54880 * been loaded.
54881 * 2) If BOTH types (the one we are adding casting info to, and the
54882 * cast->type) are loaded, THEN the cast info has already been loaded by
54883 * the previous module so we just ignore it.
54884 * 3) Finally, if cast->type has not already been loaded, then we add that
54885 * swig_cast_info to the linked list (because the cast->type) pointer will
54886 * be correct.
54887 * ----------------------------------------------------------------------------- */
54888
54889 #ifdef __cplusplus
54890 extern "C" {
54891 #if 0
54892 } /* c-mode */
54893 #endif
54894 #endif
54895
54896 #if 0
54897 #define SWIGRUNTIME_DEBUG
54898 #endif
54899
54900 SWIGRUNTIME void
54901 SWIG_InitializeModule(void *clientdata) {
54902 size_t i;
54903 swig_module_info *module_head;
54904 static int init_run = 0;
54905
54906 clientdata = clientdata;
54907
54908 if (init_run) return;
54909 init_run = 1;
54910
54911 /* Initialize the swig_module */
54912 swig_module.type_initial = swig_type_initial;
54913 swig_module.cast_initial = swig_cast_initial;
54914
54915 /* Try and load any already created modules */
54916 module_head = SWIG_GetModule(clientdata);
54917 if (module_head) {
54918 swig_module.next = module_head->next;
54919 module_head->next = &swig_module;
54920 } else {
54921 /* This is the first module loaded */
54922 swig_module.next = &swig_module;
54923 SWIG_SetModule(clientdata, &swig_module);
54924 }
54925
54926 /* Now work on filling in swig_module.types */
54927 #ifdef SWIGRUNTIME_DEBUG
54928 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
54929 #endif
54930 for (i = 0; i < swig_module.size; ++i) {
54931 swig_type_info *type = 0;
54932 swig_type_info *ret;
54933 swig_cast_info *cast;
54934
54935 #ifdef SWIGRUNTIME_DEBUG
54936 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54937 #endif
54938
54939 /* if there is another module already loaded */
54940 if (swig_module.next != &swig_module) {
54941 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
54942 }
54943 if (type) {
54944 /* Overwrite clientdata field */
54945 #ifdef SWIGRUNTIME_DEBUG
54946 printf("SWIG_InitializeModule: found type %s\n", type->name);
54947 #endif
54948 if (swig_module.type_initial[i]->clientdata) {
54949 type->clientdata = swig_module.type_initial[i]->clientdata;
54950 #ifdef SWIGRUNTIME_DEBUG
54951 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
54952 #endif
54953 }
54954 } else {
54955 type = swig_module.type_initial[i];
54956 }
54957
54958 /* Insert casting types */
54959 cast = swig_module.cast_initial[i];
54960 while (cast->type) {
54961 /* Don't need to add information already in the list */
54962 ret = 0;
54963 #ifdef SWIGRUNTIME_DEBUG
54964 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
54965 #endif
54966 if (swig_module.next != &swig_module) {
54967 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
54968 #ifdef SWIGRUNTIME_DEBUG
54969 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
54970 #endif
54971 }
54972 if (ret) {
54973 if (type == swig_module.type_initial[i]) {
54974 #ifdef SWIGRUNTIME_DEBUG
54975 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
54976 #endif
54977 cast->type = ret;
54978 ret = 0;
54979 } else {
54980 /* Check for casting already in the list */
54981 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
54982 #ifdef SWIGRUNTIME_DEBUG
54983 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
54984 #endif
54985 if (!ocast) ret = 0;
54986 }
54987 }
54988
54989 if (!ret) {
54990 #ifdef SWIGRUNTIME_DEBUG
54991 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
54992 #endif
54993 if (type->cast) {
54994 type->cast->prev = cast;
54995 cast->next = type->cast;
54996 }
54997 type->cast = cast;
54998 }
54999 cast++;
55000 }
55001 /* Set entry in modules->types array equal to the type */
55002 swig_module.types[i] = type;
55003 }
55004 swig_module.types[i] = 0;
55005
55006 #ifdef SWIGRUNTIME_DEBUG
55007 printf("**** SWIG_InitializeModule: Cast List ******\n");
55008 for (i = 0; i < swig_module.size; ++i) {
55009 int j = 0;
55010 swig_cast_info *cast = swig_module.cast_initial[i];
55011 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55012 while (cast->type) {
55013 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55014 cast++;
55015 ++j;
55016 }
55017 printf("---- Total casts: %d\n",j);
55018 }
55019 printf("**** SWIG_InitializeModule: Cast List ******\n");
55020 #endif
55021 }
55022
55023 /* This function will propagate the clientdata field of type to
55024 * any new swig_type_info structures that have been added into the list
55025 * of equivalent types. It is like calling
55026 * SWIG_TypeClientData(type, clientdata) a second time.
55027 */
55028 SWIGRUNTIME void
55029 SWIG_PropagateClientData(void) {
55030 size_t i;
55031 swig_cast_info *equiv;
55032 static int init_run = 0;
55033
55034 if (init_run) return;
55035 init_run = 1;
55036
55037 for (i = 0; i < swig_module.size; i++) {
55038 if (swig_module.types[i]->clientdata) {
55039 equiv = swig_module.types[i]->cast;
55040 while (equiv) {
55041 if (!equiv->converter) {
55042 if (equiv->type && !equiv->type->clientdata)
55043 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55044 }
55045 equiv = equiv->next;
55046 }
55047 }
55048 }
55049 }
55050
55051 #ifdef __cplusplus
55052 #if 0
55053 {
55054 /* c-mode */
55055 #endif
55056 }
55057 #endif
55058
55059
55060
55061 #ifdef __cplusplus
55062 extern "C" {
55063 #endif
55064
55065 /* Python-specific SWIG API */
55066 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55067 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55068 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55069
55070 /* -----------------------------------------------------------------------------
55071 * global variable support code.
55072 * ----------------------------------------------------------------------------- */
55073
55074 typedef struct swig_globalvar {
55075 char *name; /* Name of global variable */
55076 PyObject *(*get_attr)(void); /* Return the current value */
55077 int (*set_attr)(PyObject *); /* Set the value */
55078 struct swig_globalvar *next;
55079 } swig_globalvar;
55080
55081 typedef struct swig_varlinkobject {
55082 PyObject_HEAD
55083 swig_globalvar *vars;
55084 } swig_varlinkobject;
55085
55086 SWIGINTERN PyObject *
55087 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55088 return PyString_FromString("<Swig global variables>");
55089 }
55090
55091 SWIGINTERN PyObject *
55092 swig_varlink_str(swig_varlinkobject *v) {
55093 PyObject *str = PyString_FromString("(");
55094 swig_globalvar *var;
55095 for (var = v->vars; var; var=var->next) {
55096 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55097 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55098 }
55099 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55100 return str;
55101 }
55102
55103 SWIGINTERN int
55104 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55105 PyObject *str = swig_varlink_str(v);
55106 fprintf(fp,"Swig global variables ");
55107 fprintf(fp,"%s\n", PyString_AsString(str));
55108 Py_DECREF(str);
55109 return 0;
55110 }
55111
55112 SWIGINTERN void
55113 swig_varlink_dealloc(swig_varlinkobject *v) {
55114 swig_globalvar *var = v->vars;
55115 while (var) {
55116 swig_globalvar *n = var->next;
55117 free(var->name);
55118 free(var);
55119 var = n;
55120 }
55121 }
55122
55123 SWIGINTERN PyObject *
55124 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55125 PyObject *res = NULL;
55126 swig_globalvar *var = v->vars;
55127 while (var) {
55128 if (strcmp(var->name,n) == 0) {
55129 res = (*var->get_attr)();
55130 break;
55131 }
55132 var = var->next;
55133 }
55134 if (res == NULL && !PyErr_Occurred()) {
55135 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55136 }
55137 return res;
55138 }
55139
55140 SWIGINTERN int
55141 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55142 int res = 1;
55143 swig_globalvar *var = v->vars;
55144 while (var) {
55145 if (strcmp(var->name,n) == 0) {
55146 res = (*var->set_attr)(p);
55147 break;
55148 }
55149 var = var->next;
55150 }
55151 if (res == 1 && !PyErr_Occurred()) {
55152 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55153 }
55154 return res;
55155 }
55156
55157 SWIGINTERN PyTypeObject*
55158 swig_varlink_type(void) {
55159 static char varlink__doc__[] = "Swig var link object";
55160 static PyTypeObject varlink_type;
55161 static int type_init = 0;
55162 if (!type_init) {
55163 const PyTypeObject tmp
55164 = {
55165 PyObject_HEAD_INIT(NULL)
55166 0, /* Number of items in variable part (ob_size) */
55167 (char *)"swigvarlink", /* Type name (tp_name) */
55168 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55169 0, /* Itemsize (tp_itemsize) */
55170 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55171 (printfunc) swig_varlink_print, /* Print (tp_print) */
55172 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55173 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55174 0, /* tp_compare */
55175 (reprfunc) swig_varlink_repr, /* tp_repr */
55176 0, /* tp_as_number */
55177 0, /* tp_as_sequence */
55178 0, /* tp_as_mapping */
55179 0, /* tp_hash */
55180 0, /* tp_call */
55181 (reprfunc)swig_varlink_str, /* tp_str */
55182 0, /* tp_getattro */
55183 0, /* tp_setattro */
55184 0, /* tp_as_buffer */
55185 0, /* tp_flags */
55186 varlink__doc__, /* tp_doc */
55187 0, /* tp_traverse */
55188 0, /* tp_clear */
55189 0, /* tp_richcompare */
55190 0, /* tp_weaklistoffset */
55191 #if PY_VERSION_HEX >= 0x02020000
55192 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55193 #endif
55194 #if PY_VERSION_HEX >= 0x02030000
55195 0, /* tp_del */
55196 #endif
55197 #ifdef COUNT_ALLOCS
55198 0,0,0,0 /* tp_alloc -> tp_next */
55199 #endif
55200 };
55201 varlink_type = tmp;
55202 varlink_type.ob_type = &PyType_Type;
55203 type_init = 1;
55204 }
55205 return &varlink_type;
55206 }
55207
55208 /* Create a variable linking object for use later */
55209 SWIGINTERN PyObject *
55210 SWIG_Python_newvarlink(void) {
55211 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55212 if (result) {
55213 result->vars = 0;
55214 }
55215 return ((PyObject*) result);
55216 }
55217
55218 SWIGINTERN void
55219 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55220 swig_varlinkobject *v = (swig_varlinkobject *) p;
55221 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55222 if (gv) {
55223 size_t size = strlen(name)+1;
55224 gv->name = (char *)malloc(size);
55225 if (gv->name) {
55226 strncpy(gv->name,name,size);
55227 gv->get_attr = get_attr;
55228 gv->set_attr = set_attr;
55229 gv->next = v->vars;
55230 }
55231 }
55232 v->vars = gv;
55233 }
55234
55235 SWIGINTERN PyObject *
55236 SWIG_globals() {
55237 static PyObject *_SWIG_globals = 0;
55238 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55239 return _SWIG_globals;
55240 }
55241
55242 /* -----------------------------------------------------------------------------
55243 * constants/methods manipulation
55244 * ----------------------------------------------------------------------------- */
55245
55246 /* Install Constants */
55247 SWIGINTERN void
55248 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55249 PyObject *obj = 0;
55250 size_t i;
55251 for (i = 0; constants[i].type; ++i) {
55252 switch(constants[i].type) {
55253 case SWIG_PY_POINTER:
55254 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55255 break;
55256 case SWIG_PY_BINARY:
55257 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55258 break;
55259 default:
55260 obj = 0;
55261 break;
55262 }
55263 if (obj) {
55264 PyDict_SetItemString(d, constants[i].name, obj);
55265 Py_DECREF(obj);
55266 }
55267 }
55268 }
55269
55270 /* -----------------------------------------------------------------------------*/
55271 /* Fix SwigMethods to carry the callback ptrs when needed */
55272 /* -----------------------------------------------------------------------------*/
55273
55274 SWIGINTERN void
55275 SWIG_Python_FixMethods(PyMethodDef *methods,
55276 swig_const_info *const_table,
55277 swig_type_info **types,
55278 swig_type_info **types_initial) {
55279 size_t i;
55280 for (i = 0; methods[i].ml_name; ++i) {
55281 char *c = methods[i].ml_doc;
55282 if (c && (c = strstr(c, "swig_ptr: "))) {
55283 int j;
55284 swig_const_info *ci = 0;
55285 char *name = c + 10;
55286 for (j = 0; const_table[j].type; ++j) {
55287 if (strncmp(const_table[j].name, name,
55288 strlen(const_table[j].name)) == 0) {
55289 ci = &(const_table[j]);
55290 break;
55291 }
55292 }
55293 if (ci) {
55294 size_t shift = (ci->ptype) - types;
55295 swig_type_info *ty = types_initial[shift];
55296 size_t ldoc = (c - methods[i].ml_doc);
55297 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55298 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55299 if (ndoc) {
55300 char *buff = ndoc;
55301 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55302 if (ptr) {
55303 strncpy(buff, methods[i].ml_doc, ldoc);
55304 buff += ldoc;
55305 strncpy(buff, "swig_ptr: ", 10);
55306 buff += 10;
55307 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55308 methods[i].ml_doc = ndoc;
55309 }
55310 }
55311 }
55312 }
55313 }
55314 }
55315
55316 #ifdef __cplusplus
55317 }
55318 #endif
55319
55320 /* -----------------------------------------------------------------------------*
55321 * Partial Init method
55322 * -----------------------------------------------------------------------------*/
55323
55324 #ifdef __cplusplus
55325 extern "C"
55326 #endif
55327 SWIGEXPORT void SWIG_init(void) {
55328 PyObject *m, *d;
55329
55330 /* Fix SwigMethods to carry the callback ptrs when needed */
55331 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55332
55333 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55334 d = PyModule_GetDict(m);
55335
55336 SWIG_InitializeModule(0);
55337 SWIG_InstallConstants(d,swig_const_table);
55338
55339
55340
55341 #ifndef wxPyUSE_EXPORT
55342 // Make our API structure a CObject so other modules can import it
55343 // from this module.
55344 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55345 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55346 Py_XDECREF(cobj);
55347 #endif
55348
55349 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55350 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55351 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55352 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55353 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55354 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55355 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55356 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55357 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55358 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55359 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55360 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55361 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55362 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55363 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55364 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55365 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55366 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55367 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55368 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55369 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55370 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55371 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55372 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55373 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55374 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55375 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55376 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55377 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55378 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55379 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55380 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55381 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55382 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55383 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55384 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55385 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55386 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55387 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55388 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55389 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55390 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55391 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55392 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55393 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55394 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55395 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55396 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55397 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55398 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55399 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55400 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55401 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55402 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55403 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55404 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55405 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55406 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55407 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55408 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55409 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55410 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55411 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55412 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55413 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55414 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55415 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55416 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55417 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55418 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55419 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55420 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55421 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55422 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55423 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55424 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55425 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55426 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55427 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55428 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55429 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55430 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55431 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55432 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55433 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55434 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55435 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55436 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55437 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55438 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55439 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55440 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55441 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55442 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55443 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55444 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55445 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55446 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55447 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55448 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55449 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55450 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55451 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55452 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55453 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55454 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55455 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55456 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55457 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55458 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55459 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55460 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55461 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55462 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55463 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55464 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55465 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55466 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55467 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55468 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55469 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55470 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55471 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55472 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55473 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55474 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55475 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55476 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55477 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55478 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55479 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55480 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55481 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55482 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55483 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55484 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55485 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55486 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55487 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55488 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55489 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55490 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55491 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55492 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55493 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55494 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55495 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55496 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55497 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55498 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55499 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55500 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55501 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55502 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55503 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55504 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55505 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55506 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55507 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55508 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55509 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55510 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55511 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55512 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55513 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55514 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55515 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55516 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55517 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55518 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55519 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55520 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55521 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55522 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55523 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55524 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55525 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55526 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55527 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55528 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55529 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55530 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55531 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55532 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55533 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55534 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55535 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55536 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55537 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55538 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55539 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55540 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55541 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55542 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55543 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55544 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55545 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55546 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55547 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55548 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55549 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55550 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55551 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55552 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55553 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55554 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55555 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55556 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55557 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55558 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55559 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55560 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55561 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55562 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55563 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55564 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55565 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55566 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55567 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55568 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55569 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55570 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55571 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55572 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55573 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55574 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55575 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55576 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55577 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55578 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55579 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55580 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55581 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55582 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55583 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55584 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55585 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55586 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55587 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55588 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55589 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55590 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55591 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55592 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55593 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55594 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55595 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55596 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55597 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55598 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55599 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55600 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55601 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55602 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55603 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55604 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55605 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55606 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55607 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55608 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55609 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55610 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55611 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55612 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55613 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55614 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55615 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55616 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55617 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55618 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55619 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55620 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55621 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55622 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55623 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55624 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55625 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55626 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55627 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55628 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55629 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55630 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55631 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55632 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55633 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55634 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55635 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55636 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55637 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55638 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55639 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55640 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55641 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55642 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55643 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55644 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55645 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55646 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55647 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55648 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55649 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55650 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55651 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55652 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55653 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55654 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55655 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55656 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55657 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55658 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55659 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55660 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55661 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55662 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55663 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55664 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55665 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55666 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55667 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55668 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55669 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55670 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55671 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55672 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55673 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55674 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55675 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55676 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55677 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55678 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55679 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55680 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55681 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55682 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55683 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55684 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55685 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55686 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55687 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55688 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55689 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55690 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55691 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55692 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55693 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55694 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55695 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55696 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55697 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55698 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55699 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55700 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55701 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55702 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55703 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55704 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55705 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55706 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55707 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55708 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55709 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55710 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55711 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55712 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55713 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55714 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55715 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55716 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55717 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55718 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55719 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55720 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55721 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55722 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55723 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55724 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55725 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55726 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55727 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55728 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55729 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55730 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55731 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55732 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55733 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55734 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55735 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55736 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55737 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55738 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55739 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55740 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55741 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55742 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55743 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55744 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55745 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55746 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55747 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55748 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55749 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55750 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55751 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55752 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55753 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55754 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55755 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55756 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55757 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55758 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55759 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55760 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55761 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55762 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55763 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55764 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55765 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55766 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55767 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55768 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55769 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55770 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55771 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55772 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55773 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55774 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55775 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55776 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55777 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55778 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55779 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55780 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55781 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55782 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55783 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55784 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55785 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55786 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55787 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55788 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55789 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55790 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55791 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55792 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55793 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55794 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55795 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55796 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55797 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55798 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55799 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55800 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55801 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55802 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55803 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55804 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55805 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55806 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55807 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55808 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55809 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55810 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55811 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55812 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55813 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55814 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55815 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55816 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55817 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55818 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55819 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55820 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55821 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55822 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55823 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55824 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55825 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55826 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55827 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55828 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55829 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55830 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55831 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55832 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55833 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55834 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55835 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55836 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55837 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55838 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55839 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55840 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55841 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55842 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55843 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55844 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55845 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55846 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55847 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55848 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55849 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55850 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55851 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55852 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55853 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55854 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55855 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55856 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55857 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55858 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55859 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55860 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55861 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55862 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55863 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55864 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55865 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55866 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55867 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55868 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55869 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55870 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55871 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55872 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55873 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55874 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55875 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
55876 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
55877 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
55878 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
55879 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
55880 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
55881 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
55882 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
55883 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
55884 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
55885 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
55886 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
55887 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
55888 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
55889 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
55890 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
55891 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
55892 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
55893 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
55894 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
55895 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
55896 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
55897 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
55898 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
55899 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
55900 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
55901 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
55902 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
55903 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
55904 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
55905 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
55906 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
55907 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
55908 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
55909 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
55910 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
55911 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
55912 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
55913 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
55914 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
55915 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
55916 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
55917 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
55918 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
55919 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
55920 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
55921 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
55922 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
55923 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
55924 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
55925 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
55926 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
55927 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
55928 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
55929 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
55930 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
55931 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
55932 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
55933 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
55934 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
55935 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
55936 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
55937 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
55938 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
55939 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
55940 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
55941 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
55942 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
55943 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
55944 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
55945 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
55946 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
55947 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
55948 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
55949 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
55950 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
55951 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
55952 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
55953 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
55954 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
55955 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
55956 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
55957 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
55958 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
55959 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
55960 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
55961 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
55962 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
55963 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
55964 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
55965 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
55966 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
55967 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
55968 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
55969 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
55970 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
55971 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
55972 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
55973 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
55974 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
55975 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
55976 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
55977 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
55978 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
55979 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
55980 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
55981 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
55982 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
55983 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
55984 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
55985 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
55986 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
55987 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
55988 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
55989 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
55990 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
55991 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
55992 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
55993 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
55994 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
55995 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
55996 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
55997 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
55998 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
55999 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56000 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56001 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56002 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56003 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56004 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56005 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56006 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56007 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56008 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56009 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56010 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56011 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56012 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56013 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56014 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56015 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56016 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56017 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56018
56019 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56020
56021
56022 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56023
56024 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56025 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56026 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56027 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56028 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56029 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56030 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56031 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56032 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56033 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56034 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56035 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56036 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56037 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56038 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56039 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56040 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56041 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56042 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56043 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56044 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56045 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56046 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56047 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56048 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56049 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56050 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56051 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56052 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56053 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56054 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56055 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56056 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56057 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56058 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56059 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56060 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56061 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56062 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56063 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56064 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56065 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56066 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56067 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56068 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56069 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56070 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56071 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56072 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56073 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56074 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56075 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56076 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56077 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56078 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56079 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56080 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56081 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56082 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56083 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56084 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56085 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56086 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56087 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56088 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56089 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56090 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56091 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56092 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56093 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56094 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56095 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56096 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56097 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56098 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56099 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56100 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56101 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56102 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56103 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56104 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56105 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56106 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56107 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56108 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56109 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56110 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56111 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56112 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56113 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56114 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56115 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56116 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56117 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56118 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56119 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56120 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56121 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56122 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56123 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56124 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56125 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56126 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56127 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56128 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56129 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56130 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56131 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56132 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56133 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56134 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56135 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56136 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56137 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56138 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56139 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56140 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56141 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56142 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56143 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56144 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56145 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56146 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56147 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56148 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56149 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56150 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56151 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56152 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56153 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56154 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56155 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56156 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56157 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56158 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56159 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56160 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56161 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56162 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56163 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56164 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56165 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56166 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56167 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56168 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56169 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56170 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56171 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56172 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56173 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56174 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56175 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56176 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56177 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56178 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56179 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56180 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56181 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56182 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56183 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56184 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56185 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56186 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56187 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56188 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56189 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56190 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56191 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56192 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56193 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56194 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56195 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56196 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56197 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56198 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56199 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56200 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56201 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56202 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56203 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56204 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56205 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56206 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56207 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56208 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56209 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56210 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56211 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56212 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56213 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56214 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56215 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56216 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56217 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56218 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56219 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56220 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56221 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56222 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56223 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56224 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56225 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56226 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56227 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56228
56229 // Initialize threading, some globals and such
56230 __wxPyPreStart(d);
56231
56232
56233 // Although these are defined in __version__ they need to be here too so
56234 // that an assert can be done to ensure that the wxPython and the wxWindows
56235 // versions match.
56236 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56237 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56238 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56239
56240 }
56241
wxWidgets (Impactor)