]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2484 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2485 #define SWIGTYPE_p_wxColour swig_types[23]
2486 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2487 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2488 #define SWIGTYPE_p_wxControl swig_types[26]
2489 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2490 #define SWIGTYPE_p_wxCursor swig_types[28]
2491 #define SWIGTYPE_p_wxDC swig_types[29]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2493 #define SWIGTYPE_p_wxDateTime swig_types[31]
2494 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2496 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2497 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEvent swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2500 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2501 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2502 #define SWIGTYPE_p_wxFSFile swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2504 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2505 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2506 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2507 #define SWIGTYPE_p_wxFont swig_types[45]
2508 #define SWIGTYPE_p_wxFrame swig_types[46]
2509 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2510 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2511 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2512 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2513 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2514 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2515 #define SWIGTYPE_p_wxICOHandler swig_types[53]
2516 #define SWIGTYPE_p_wxIconizeEvent swig_types[54]
2517 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
2518 #define SWIGTYPE_p_wxImage swig_types[56]
2519 #define SWIGTYPE_p_wxImageHandler swig_types[57]
2520 #define SWIGTYPE_p_wxImageHistogram swig_types[58]
2521 #define SWIGTYPE_p_wxImage_HSVValue swig_types[59]
2522 #define SWIGTYPE_p_wxImage_RGBValue swig_types[60]
2523 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[61]
2524 #define SWIGTYPE_p_wxInitDialogEvent swig_types[62]
2525 #define SWIGTYPE_p_wxInputStream swig_types[63]
2526 #define SWIGTYPE_p_wxInternetFSHandler swig_types[64]
2527 #define SWIGTYPE_p_wxItemContainer swig_types[65]
2528 #define SWIGTYPE_p_wxJPEGHandler swig_types[66]
2529 #define SWIGTYPE_p_wxKeyEvent swig_types[67]
2530 #define SWIGTYPE_p_wxLayoutConstraints swig_types[68]
2531 #define SWIGTYPE_p_wxMaximizeEvent swig_types[69]
2532 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
2533 #define SWIGTYPE_p_wxMenu swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBar swig_types[72]
2535 #define SWIGTYPE_p_wxMenuBarBase swig_types[73]
2536 #define SWIGTYPE_p_wxMenuEvent swig_types[74]
2537 #define SWIGTYPE_p_wxMenuItem swig_types[75]
2538 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMouseEvent swig_types[77]
2540 #define SWIGTYPE_p_wxMoveEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNcPaintEvent swig_types[80]
2543 #define SWIGTYPE_p_wxNotifyEvent swig_types[81]
2544 #define SWIGTYPE_p_wxObject swig_types[82]
2545 #define SWIGTYPE_p_wxOutputStream swig_types[83]
2546 #define SWIGTYPE_p_wxPCXHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNGHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPNMHandler swig_types[86]
2549 #define SWIGTYPE_p_wxPaintEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[88]
2551 #define SWIGTYPE_p_wxPaperSize swig_types[89]
2552 #define SWIGTYPE_p_wxPoint swig_types[90]
2553 #define SWIGTYPE_p_wxPoint2D swig_types[91]
2554 #define SWIGTYPE_p_wxPropagateOnce swig_types[92]
2555 #define SWIGTYPE_p_wxPropagationDisabler swig_types[93]
2556 #define SWIGTYPE_p_wxPyApp swig_types[94]
2557 #define SWIGTYPE_p_wxPyCommandEvent swig_types[95]
2558 #define SWIGTYPE_p_wxPyDropTarget swig_types[96]
2559 #define SWIGTYPE_p_wxPyEvent swig_types[97]
2560 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyImageHandler swig_types[99]
2562 #define SWIGTYPE_p_wxPyInputStream swig_types[100]
2563 #define SWIGTYPE_p_wxPySizer swig_types[101]
2564 #define SWIGTYPE_p_wxPyValidator swig_types[102]
2565 #define SWIGTYPE_p_wxQuantize swig_types[103]
2566 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[104]
2567 #define SWIGTYPE_p_wxRealPoint swig_types[105]
2568 #define SWIGTYPE_p_wxRect swig_types[106]
2569 #define SWIGTYPE_p_wxRegion swig_types[107]
2570 #define SWIGTYPE_p_wxScrollEvent swig_types[108]
2571 #define SWIGTYPE_p_wxScrollWinEvent swig_types[109]
2572 #define SWIGTYPE_p_wxSetCursorEvent swig_types[110]
2573 #define SWIGTYPE_p_wxShowEvent swig_types[111]
2574 #define SWIGTYPE_p_wxSize swig_types[112]
2575 #define SWIGTYPE_p_wxSizeEvent swig_types[113]
2576 #define SWIGTYPE_p_wxSizer swig_types[114]
2577 #define SWIGTYPE_p_wxSizerItem swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBox swig_types[116]
2579 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[117]
2580 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[118]
2581 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[119]
2582 #define SWIGTYPE_p_wxTIFFHandler swig_types[120]
2583 #define SWIGTYPE_p_wxToolTip swig_types[121]
2584 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[122]
2585 #define SWIGTYPE_p_wxValidator swig_types[123]
2586 #define SWIGTYPE_p_wxVisualAttributes swig_types[124]
2587 #define SWIGTYPE_p_wxWindow swig_types[125]
2588 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[126]
2589 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[127]
2590 #define SWIGTYPE_p_wxXPMHandler swig_types[128]
2591 #define SWIGTYPE_p_wxZipFSHandler swig_types[129]
2592 static swig_type_info *swig_types[131];
2593 static swig_module_info swig_module = {swig_types, 130, 0, 0, 0, 0};
2594 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2595 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2596
2597 /* -------- TYPES TABLE (END) -------- */
2598
2599 #if (PY_VERSION_HEX <= 0x02000000)
2600 # if !defined(SWIG_PYTHON_CLASSIC)
2601 # error "This python version requires to use swig with the '-classic' option"
2602 # endif
2603 #endif
2604 #if (PY_VERSION_HEX <= 0x02020000)
2605 # error "This python version requires to use swig with the '-nomodern' option"
2606 #endif
2607 #if (PY_VERSION_HEX <= 0x02020000)
2608 # error "This python version requires to use swig with the '-nomodernargs' option"
2609 #endif
2610 #ifndef METH_O
2611 # error "This python version requires to use swig with the '-nofastunpack' option"
2612 #endif
2613
2614 /*-----------------------------------------------
2615 @(target):= _core_.so
2616 ------------------------------------------------*/
2617 #define SWIG_init init_core_
2618
2619 #define SWIG_name "_core_"
2620
2621 #define SWIGVERSION 0x010329
2622
2623
2624 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2625 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2626
2627
2628 #include <stdexcept>
2629
2630
2631 namespace swig {
2632 class PyObject_ptr {
2633 protected:
2634 PyObject *_obj;
2635
2636 public:
2637 PyObject_ptr() :_obj(0)
2638 {
2639 }
2640
2641 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2642 {
2643 Py_XINCREF(_obj);
2644 }
2645
2646 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2647 {
2648 if (initial_ref) Py_XINCREF(_obj);
2649 }
2650
2651 PyObject_ptr & operator=(const PyObject_ptr& item)
2652 {
2653 Py_XINCREF(item._obj);
2654 Py_XDECREF(_obj);
2655 _obj = item._obj;
2656 return *this;
2657 }
2658
2659 ~PyObject_ptr()
2660 {
2661 Py_XDECREF(_obj);
2662 }
2663
2664 operator PyObject *() const
2665 {
2666 return _obj;
2667 }
2668
2669 PyObject *operator->() const
2670 {
2671 return _obj;
2672 }
2673 };
2674 }
2675
2676
2677 namespace swig {
2678 struct PyObject_var : PyObject_ptr {
2679 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2680
2681 PyObject_var & operator = (PyObject* obj)
2682 {
2683 Py_XDECREF(_obj);
2684 _obj = obj;
2685 return *this;
2686 }
2687 };
2688 }
2689
2690
2691 #include "wx/wxPython/wxPython_int.h"
2692 #include "wx/wxPython/pyclasses.h"
2693 #include "wx/wxPython/twoitem.h"
2694
2695
2696 #ifndef wxPyUSE_EXPORT
2697 // Helper functions for dealing with SWIG objects and such. These are
2698 // located here so they know about the SWIG types and functions declared
2699 // in the wrapper code.
2700
2701 #include <wx/hashmap.h>
2702 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2703
2704
2705 // Maintains a hashmap of className to swig_type_info pointers. Given the
2706 // name of a class either looks up the type info in the cache, or scans the
2707 // SWIG tables for it.
2708 extern PyObject* wxPyPtrTypeMap;
2709 static
2710 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2711
2712 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2713
2714 if (typeInfoCache == NULL)
2715 typeInfoCache = new wxPyTypeInfoHashMap;
2716
2717 wxString name(className);
2718 swig_type_info* swigType = (*typeInfoCache)[name];
2719
2720 if (! swigType) {
2721 // it wasn't in the cache, so look it up from SWIG
2722 name.Append(wxT(" *"));
2723 swigType = SWIG_TypeQuery(name.mb_str());
2724
2725 // if it still wasn't found, try looking for a mapped name
2726 if (!swigType) {
2727 PyObject* item;
2728 name = className;
2729
2730 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2731 (char*)(const char*)name.mbc_str())) != NULL) {
2732 name = wxString(PyString_AsString(item), *wxConvCurrent);
2733 name.Append(wxT(" *"));
2734 swigType = SWIG_TypeQuery(name.mb_str());
2735 }
2736 }
2737 if (swigType) {
2738 // and add it to the map if found
2739 (*typeInfoCache)[className] = swigType;
2740 }
2741 }
2742 return swigType;
2743 }
2744
2745
2746 // Check if a class name is a type known to SWIG
2747 bool wxPyCheckSwigType(const wxChar* className) {
2748
2749 swig_type_info* swigType = wxPyFindSwigType(className);
2750 return swigType != NULL;
2751 }
2752
2753
2754 // Given a pointer to a C++ object and a class name, construct a Python proxy
2755 // object for it.
2756 PyObject* wxPyConstructObject(void* ptr,
2757 const wxChar* className,
2758 int setThisOwn) {
2759
2760 swig_type_info* swigType = wxPyFindSwigType(className);
2761 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2762
2763 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2764 }
2765
2766
2767 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2768 // Ensures that the proxy object is of the specified (or derived) type. If
2769 // not able to perform the conversion then a Python exception is set and the
2770 // error should be handled properly in the caller. Returns True on success.
2771 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2772 const wxChar* className) {
2773
2774 swig_type_info* swigType = wxPyFindSwigType(className);
2775 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2776
2777 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2778 }
2779
2780
2781
2782 // Make a SWIGified pointer object suitable for a .this attribute
2783 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2784
2785 PyObject* robj = NULL;
2786
2787 swig_type_info* swigType = wxPyFindSwigType(className);
2788 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2789
2790 robj = PySwigObject_New(ptr, swigType, 0);
2791 return robj;
2792 }
2793
2794
2795 // Python's PyInstance_Check does not return True for instances of new-style
2796 // classes. This should get close enough for both new and old classes but I
2797 // should re-evaluate the need for doing instance checks...
2798 bool wxPyInstance_Check(PyObject* obj) {
2799 return PyObject_HasAttrString(obj, "__class__") != 0;
2800 }
2801
2802
2803 // This one checks if the object is an instance of a SWIG proxy class (it has
2804 // a .this attribute, and the .this attribute is a PySwigObject.)
2805 bool wxPySwigInstance_Check(PyObject* obj) {
2806 static PyObject* this_str = NULL;
2807 if (this_str == NULL)
2808 this_str = PyString_FromString("this");
2809
2810 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2811 if (this_attr) {
2812 bool retval = (PySwigObject_Check(this_attr) != 0);
2813 Py_DECREF(this_attr);
2814 return retval;
2815 }
2816
2817 PyErr_Clear();
2818 return false;
2819 }
2820
2821
2822 // Export a C API in a struct. Other modules will be able to load this from
2823 // the wx._core_ module and will then have safe access to these functions,
2824 // even if they are located in another shared library.
2825 static wxPyCoreAPI API = {
2826
2827 wxPyCheckSwigType,
2828 wxPyConstructObject,
2829 wxPyConvertSwigPtr,
2830 wxPyMakeSwigPtr,
2831
2832 wxPyBeginAllowThreads,
2833 wxPyEndAllowThreads,
2834 wxPyBeginBlockThreads,
2835 wxPyEndBlockThreads,
2836
2837 wxPy_ConvertList,
2838
2839 wxString_in_helper,
2840 Py2wxString,
2841 wx2PyString,
2842
2843 byte_LIST_helper,
2844 int_LIST_helper,
2845 long_LIST_helper,
2846 string_LIST_helper,
2847 wxPoint_LIST_helper,
2848 wxBitmap_LIST_helper,
2849 wxString_LIST_helper,
2850 wxAcceleratorEntry_LIST_helper,
2851
2852 wxSize_helper,
2853 wxPoint_helper,
2854 wxRealPoint_helper,
2855 wxRect_helper,
2856 wxColour_helper,
2857 wxPoint2D_helper,
2858
2859 wxPySimple_typecheck,
2860 wxColour_typecheck,
2861
2862 wxPyCBH_setCallbackInfo,
2863 wxPyCBH_findCallback,
2864 wxPyCBH_callCallback,
2865 wxPyCBH_callCallbackObj,
2866 wxPyCBH_delete,
2867
2868 wxPyMake_wxObject,
2869 wxPyMake_wxSizer,
2870 wxPyPtrTypeMap_Add,
2871 wxPy2int_seq_helper,
2872 wxPy4int_seq_helper,
2873 wxArrayString2PyList_helper,
2874 wxArrayInt2PyList_helper,
2875
2876 wxPyClientData_dtor,
2877 wxPyUserData_dtor,
2878 wxPyOORClientData_dtor,
2879
2880 wxPyCBInputStream_create,
2881 wxPyCBInputStream_copy,
2882
2883 wxPyInstance_Check,
2884 wxPySwigInstance_Check,
2885
2886 wxPyCheckForApp
2887
2888 };
2889
2890 #endif
2891
2892
2893 #if !WXWIN_COMPATIBILITY_2_4
2894 #define wxHIDE_READONLY 0
2895 #endif
2896
2897
2898 #define SWIG_From_long PyInt_FromLong
2899
2900
2901 SWIGINTERNINLINE PyObject *
2902 SWIG_From_int (int value)
2903 {
2904 return SWIG_From_long (value);
2905 }
2906
2907 static const wxString wxPyEmptyString(wxEmptyString);
2908 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2909 return self->GetClassInfo()->GetClassName();
2910 }
2911 SWIGINTERN void wxObject_Destroy(wxObject *self){
2912 delete self;
2913 }
2914
2915 #ifndef __WXMAC__
2916 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2917 #endif
2918
2919
2920 #include <limits.h>
2921 #ifndef LLONG_MIN
2922 # define LLONG_MIN LONG_LONG_MIN
2923 #endif
2924 #ifndef LLONG_MAX
2925 # define LLONG_MAX LONG_LONG_MAX
2926 #endif
2927 #ifndef ULLONG_MAX
2928 # define ULLONG_MAX ULONG_LONG_MAX
2929 #endif
2930
2931
2932 SWIGINTERN int
2933 SWIG_AsVal_long (PyObject* obj, long* val)
2934 {
2935 if (PyNumber_Check(obj)) {
2936 if (val) *val = PyInt_AsLong(obj);
2937 return SWIG_OK;
2938 }
2939 return SWIG_TypeError;
2940 }
2941
2942
2943 SWIGINTERN int
2944 SWIG_AsVal_int (PyObject * obj, int *val)
2945 {
2946 long v;
2947 int res = SWIG_AsVal_long (obj, &v);
2948 if (SWIG_IsOK(res)) {
2949 if ((v < INT_MIN || v > INT_MAX)) {
2950 return SWIG_OverflowError;
2951 } else {
2952 if (val) *val = static_cast< int >(v);
2953 }
2954 }
2955 return res;
2956 }
2957
2958 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2959 wxSize temp, *obj = &temp;
2960 if ( other == Py_None ) return false;
2961 if ( ! wxSize_helper(other, &obj) ) {
2962 PyErr_Clear();
2963 return false;
2964 }
2965 return self->operator==(*obj);
2966 }
2967 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2968 wxSize temp, *obj = &temp;
2969 if ( other == Py_None ) return true;
2970 if ( ! wxSize_helper(other, &obj)) {
2971 PyErr_Clear();
2972 return true;
2973 }
2974 return self->operator!=(*obj);
2975 }
2976 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2977 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2978 PyObject* tup = PyTuple_New(2);
2979 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2980 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2981 wxPyEndBlockThreads(blocked);
2982 return tup;
2983 }
2984
2985 SWIGINTERN int
2986 SWIG_AsVal_double (PyObject *obj, double* val)
2987 {
2988 if (PyNumber_Check(obj)) {
2989 if (val) *val = PyFloat_AsDouble(obj);
2990 return SWIG_OK;
2991 }
2992 return SWIG_TypeError;
2993 }
2994
2995
2996 #define SWIG_From_double PyFloat_FromDouble
2997
2998 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
2999 wxRealPoint temp, *obj = &temp;
3000 if ( other == Py_None ) return false;
3001 if ( ! wxRealPoint_helper(other, &obj) ) {
3002 PyErr_Clear();
3003 return false;
3004 }
3005 return self->operator==(*obj);
3006 }
3007 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3008 wxRealPoint temp, *obj = &temp;
3009 if ( other == Py_None ) return true;
3010 if ( ! wxRealPoint_helper(other, &obj)) {
3011 PyErr_Clear();
3012 return true;
3013 }
3014 return self->operator!=(*obj);
3015 }
3016 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3017 self->x = x;
3018 self->y = y;
3019 }
3020 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3021 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3022 PyObject* tup = PyTuple_New(2);
3023 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3024 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3025 wxPyEndBlockThreads(blocked);
3026 return tup;
3027 }
3028 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3029 wxPoint temp, *obj = &temp;
3030 if ( other == Py_None ) return false;
3031 if ( ! wxPoint_helper(other, &obj) ) {
3032 PyErr_Clear();
3033 return false;
3034 }
3035 return self->operator==(*obj);
3036 }
3037 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3038 wxPoint temp, *obj = &temp;
3039 if ( other == Py_None ) return true;
3040 if ( ! wxPoint_helper(other, &obj)) {
3041 PyErr_Clear();
3042 return true;
3043 }
3044 return self->operator!=(*obj);
3045 }
3046 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3047 self->x = x;
3048 self->y = y;
3049 }
3050 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3051 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3052 PyObject* tup = PyTuple_New(2);
3053 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3054 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3055 wxPyEndBlockThreads(blocked);
3056 return tup;
3057 }
3058 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3059 wxRect temp, *obj = &temp;
3060 if ( other == Py_None ) return false;
3061 if ( ! wxRect_helper(other, &obj) ) {
3062 PyErr_Clear();
3063 return false;
3064 }
3065 return self->operator==(*obj);
3066 }
3067 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3068 wxRect temp, *obj = &temp;
3069 if ( other == Py_None ) return true;
3070 if ( ! wxRect_helper(other, &obj)) {
3071 PyErr_Clear();
3072 return true;
3073 }
3074 return self->operator!=(*obj);
3075 }
3076 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3077 self->x = x;
3078 self->y = y;
3079 self->width = width;
3080 self->height = height;
3081 }
3082 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 PyObject* tup = PyTuple_New(4);
3085 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3086 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3087 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3088 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3089 wxPyEndBlockThreads(blocked);
3090 return tup;
3091 }
3092
3093 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3094 wxRegion reg1(*r1);
3095 wxRegion reg2(*r2);
3096 wxRect dest(0,0,0,0);
3097 PyObject* obj;
3098
3099 reg1.Intersect(reg2);
3100 dest = reg1.GetBox();
3101
3102 if (dest != wxRect(0,0,0,0)) {
3103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3104 wxRect* newRect = new wxRect(dest);
3105 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3106 wxPyEndBlockThreads(blocked);
3107 return obj;
3108 }
3109 Py_INCREF(Py_None);
3110 return Py_None;
3111 }
3112
3113 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3114 wxPoint2D temp, *obj = &temp;
3115 if ( other == Py_None ) return false;
3116 if ( ! wxPoint2D_helper(other, &obj) ) {
3117 PyErr_Clear();
3118 return false;
3119 }
3120 return self->operator==(*obj);
3121 }
3122 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3123 wxPoint2D temp, *obj = &temp;
3124 if ( other == Py_None ) return true;
3125 if ( ! wxPoint2D_helper(other, &obj)) {
3126 PyErr_Clear();
3127 return true;
3128 }
3129 return self->operator!=(*obj);
3130 }
3131 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3132 self->m_x = x;
3133 self->m_y = y;
3134 }
3135 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3136 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3137 PyObject* tup = PyTuple_New(2);
3138 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3139 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3140 wxPyEndBlockThreads(blocked);
3141 return tup;
3142 }
3143
3144 #include "wx/wxPython/pyistream.h"
3145
3146 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3147 wxInputStream* wxis = wxPyCBInputStream::create(p);
3148 if (wxis)
3149 return new wxPyInputStream(wxis);
3150 else
3151 return NULL;
3152 }
3153
3154 SWIGINTERN swig_type_info*
3155 SWIG_pchar_descriptor()
3156 {
3157 static int init = 0;
3158 static swig_type_info* info = 0;
3159 if (!init) {
3160 info = SWIG_TypeQuery("_p_char");
3161 init = 1;
3162 }
3163 return info;
3164 }
3165
3166
3167 SWIGINTERNINLINE PyObject *
3168 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3169 {
3170 if (carray) {
3171 if (size > INT_MAX) {
3172 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3173 return pchar_descriptor ?
3174 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3175 } else {
3176 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3177 }
3178 } else {
3179 return SWIG_Py_Void();
3180 }
3181 }
3182
3183
3184 SWIGINTERNINLINE PyObject *
3185 SWIG_From_char (char c)
3186 {
3187 return SWIG_FromCharPtrAndSize(&c,1);
3188 }
3189
3190
3191 SWIGINTERNINLINE PyObject*
3192 SWIG_From_unsigned_SS_long (unsigned long value)
3193 {
3194 return (value > LONG_MAX) ?
3195 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3196 }
3197
3198
3199 SWIGINTERNINLINE PyObject *
3200 SWIG_From_size_t (size_t value)
3201 {
3202 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3203 }
3204
3205
3206 SWIGINTERN int
3207 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3208 {
3209 if (PyString_Check(obj)) {
3210 char *cstr; int len;
3211 PyString_AsStringAndSize(obj, &cstr, &len);
3212 if (cptr) {
3213 if (alloc) {
3214 /*
3215 In python the user should not be able to modify the inner
3216 string representation. To warranty that, if you define
3217 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3218 buffer is always returned.
3219
3220 The default behavior is just to return the pointer value,
3221 so, be careful.
3222 */
3223 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3224 if (*alloc != SWIG_OLDOBJ)
3225 #else
3226 if (*alloc == SWIG_NEWOBJ)
3227 #endif
3228 {
3229 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3230 *alloc = SWIG_NEWOBJ;
3231 }
3232 else {
3233 *cptr = cstr;
3234 *alloc = SWIG_OLDOBJ;
3235 }
3236 } else {
3237 *cptr = PyString_AsString(obj);
3238 }
3239 }
3240 if (psize) *psize = len + 1;
3241 return SWIG_OK;
3242 } else {
3243 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3244 if (pchar_descriptor) {
3245 void* vptr = 0;
3246 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3247 if (cptr) *cptr = (char *) vptr;
3248 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3249 if (alloc) *alloc = SWIG_OLDOBJ;
3250 return SWIG_OK;
3251 }
3252 }
3253 }
3254 return SWIG_TypeError;
3255 }
3256
3257
3258 SWIGINTERN int
3259 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3260 {
3261 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3262 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3263 if (SWIG_IsOK(res)) {
3264 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3265 if (csize <= size) {
3266 if (val) {
3267 if (csize) memcpy(val, cptr, csize*sizeof(char));
3268 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3269 }
3270 if (alloc == SWIG_NEWOBJ) {
3271 delete[] cptr;
3272 res = SWIG_DelNewMask(res);
3273 }
3274 return res;
3275 }
3276 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3277 }
3278 return SWIG_TypeError;
3279 }
3280
3281
3282 SWIGINTERN int
3283 SWIG_AsVal_char (PyObject * obj, char *val)
3284 {
3285 int res = SWIG_AsCharArray(obj, val, 1);
3286 if (!SWIG_IsOK(res)) {
3287 long v;
3288 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3289 if (SWIG_IsOK(res)) {
3290 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3291 if (val) *val = static_cast< char >(v);
3292 } else {
3293 res = SWIG_OverflowError;
3294 }
3295 }
3296 }
3297 return res;
3298 }
3299
3300 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3301 // We use only strings for the streams, not unicode
3302 PyObject* str = PyObject_Str(obj);
3303 if (! str) {
3304 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3305 return;
3306 }
3307 self->Write(PyString_AS_STRING(str),
3308 PyString_GET_SIZE(str));
3309 Py_DECREF(str);
3310 }
3311
3312 #include "wx/wxPython/pyistream.h"
3313
3314
3315 class wxPyFileSystemHandler : public wxFileSystemHandler
3316 {
3317 public:
3318 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3319
3320 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3321 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3322 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3323 DEC_PYCALLBACK_STRING__pure(FindNext);
3324
3325 wxString GetProtocol(const wxString& location) {
3326 return wxFileSystemHandler::GetProtocol(location);
3327 }
3328
3329 wxString GetLeftLocation(const wxString& location) {
3330 return wxFileSystemHandler::GetLeftLocation(location);
3331 }
3332
3333 wxString GetAnchor(const wxString& location) {
3334 return wxFileSystemHandler::GetAnchor(location);
3335 }
3336
3337 wxString GetRightLocation(const wxString& location) {
3338 return wxFileSystemHandler::GetRightLocation(location);
3339 }
3340
3341 wxString GetMimeTypeFromExt(const wxString& location) {
3342 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3343 }
3344
3345 PYPRIVATE;
3346 };
3347
3348
3349 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3350 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3351 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3352 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3353
3354
3355 SWIGINTERN int
3356 SWIG_AsVal_bool (PyObject *obj, bool *val)
3357 {
3358 if (obj == Py_True) {
3359 if (val) *val = true;
3360 return SWIG_OK;
3361 } else if (obj == Py_False) {
3362 if (val) *val = false;
3363 return SWIG_OK;
3364 } else {
3365 long v = 0;
3366 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3367 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3368 return res;
3369 }
3370 }
3371
3372 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3373 wxFileName fname = wxFileSystem::URLToFileName(url);
3374 return fname.GetFullPath();
3375 }
3376
3377 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3378 wxImage& image,
3379 long type) {
3380 wxMemoryFSHandler::AddFile(filename, image, type);
3381 }
3382
3383 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3384 const wxBitmap& bitmap,
3385 long type) {
3386 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3387 }
3388
3389 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3390 PyObject* data) {
3391 if (! PyString_Check(data)) {
3392 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3393 "Expected string object"));
3394 return;
3395 }
3396
3397 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3398 void* ptr = (void*)PyString_AsString(data);
3399 size_t size = PyString_Size(data);
3400 wxPyEndBlockThreads(blocked);
3401
3402 wxMemoryFSHandler::AddFile(filename, ptr, size);
3403 }
3404
3405
3406 #include "wx/wxPython/pyistream.h"
3407
3408
3409 SWIGINTERN int
3410 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3411 {
3412 long v = 0;
3413 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3414 return SWIG_TypeError;
3415 }
3416 else if (val)
3417 *val = (unsigned long)v;
3418 return SWIG_OK;
3419 }
3420
3421
3422 SWIGINTERN int
3423 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3424 {
3425 unsigned long v;
3426 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3427 if (SWIG_IsOK(res)) {
3428 if ((v > UCHAR_MAX)) {
3429 return SWIG_OverflowError;
3430 } else {
3431 if (val) *val = static_cast< unsigned char >(v);
3432 }
3433 }
3434 return res;
3435 }
3436
3437
3438 SWIGINTERNINLINE PyObject *
3439 SWIG_From_unsigned_SS_char (unsigned char value)
3440 {
3441 return SWIG_From_unsigned_SS_long (value);
3442 }
3443
3444 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3445 wxImageHistogramEntry e = (*self)[key];
3446 return e.value;
3447 }
3448 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3449 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3450 wxImageHistogramEntry e = (*self)[key];
3451 return e.value;
3452 }
3453 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3454 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3455 colour.Green(),
3456 colour.Blue());
3457 wxImageHistogramEntry e = (*self)[key];
3458 return e.value;
3459 }
3460
3461 typedef unsigned char* buffer;
3462
3463
3464 // Pull the nested class out to the top level for SWIG's sake
3465 #define wxImage_RGBValue wxImage::RGBValue
3466 #define wxImage_HSVValue wxImage::HSVValue
3467
3468 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3469 if (width > 0 && height > 0)
3470 return new wxImage(width, height, clear);
3471 else
3472 return new wxImage;
3473 }
3474 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3475 return new wxImage(bitmap.ConvertToImage());
3476 }
3477 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3478 if (DATASIZE != width*height*3) {
3479 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3480 return NULL;
3481 }
3482
3483 // Copy the source data so the wxImage can clean it up later
3484 buffer copy = (buffer)malloc(DATASIZE);
3485 if (copy == NULL) {
3486 wxPyBLOCK_THREADS(PyErr_NoMemory());
3487 return NULL;
3488 }
3489 memcpy(copy, data, DATASIZE);
3490 return new wxImage(width, height, copy, false);
3491 }
3492 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3493 if (DATASIZE != width*height*3) {
3494 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3495 return NULL;
3496 }
3497 if (ALPHASIZE != width*height) {
3498 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3499 return NULL;
3500 }
3501
3502 // Copy the source data so the wxImage can clean it up later
3503 buffer dcopy = (buffer)malloc(DATASIZE);
3504 if (dcopy == NULL) {
3505 wxPyBLOCK_THREADS(PyErr_NoMemory());
3506 return NULL;
3507 }
3508 memcpy(dcopy, data, DATASIZE);
3509
3510 buffer acopy = (buffer)malloc(ALPHASIZE);
3511 if (acopy == NULL) {
3512 wxPyBLOCK_THREADS(PyErr_NoMemory());
3513 return NULL;
3514 }
3515 memcpy(acopy, alpha, ALPHASIZE);
3516
3517 return new wxImage(width, height, dcopy, acopy, false);
3518 }
3519 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3520 wxSize size(self->GetWidth(), self->GetHeight());
3521 return size;
3522 }
3523 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3524 buffer data = self->GetData();
3525 int len = self->GetWidth() * self->GetHeight() * 3;
3526 PyObject* rv;
3527 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3528 return rv;
3529 }
3530 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3531 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3532 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3533 return;
3534 }
3535 buffer copy = (buffer)malloc(DATASIZE);
3536 if (copy == NULL) {
3537 wxPyBLOCK_THREADS(PyErr_NoMemory());
3538 return;
3539 }
3540 memcpy(copy, data, DATASIZE);
3541 self->SetData(copy, false);
3542 // wxImage takes ownership of copy...
3543 }
3544 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3545 buffer data = self->GetData();
3546 int len = self->GetWidth() * self->GetHeight() * 3;
3547 PyObject* rv;
3548 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3549 return rv;
3550 }
3551 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3552 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3553 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3554 return;
3555 }
3556 self->SetData(data, true);
3557 }
3558 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3559 buffer data = self->GetAlpha();
3560 if (! data) {
3561 RETURN_NONE();
3562 } else {
3563 int len = self->GetWidth() * self->GetHeight();
3564 PyObject* rv;
3565 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3566 return rv;
3567 }
3568 }
3569 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3570 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3571 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3572 return;
3573 }
3574 buffer acopy = (buffer)malloc(ALPHASIZE);
3575 if (acopy == NULL) {
3576 wxPyBLOCK_THREADS(PyErr_NoMemory());
3577 return;
3578 }
3579 memcpy(acopy, alpha, ALPHASIZE);
3580 self->SetAlpha(acopy, false);
3581 // wxImage takes ownership of acopy...
3582 }
3583 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3584 buffer data = self->GetAlpha();
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3588 return rv;
3589 }
3590 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3591 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3592 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3593 return;
3594 }
3595 self->SetAlpha(alpha, true);
3596 }
3597 SWIGINTERN PyObject *wxImage_GetHandlers(){
3598 wxList& list = wxImage::GetHandlers();
3599 return wxPy_ConvertList(&list);
3600 }
3601 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3602 wxBitmap bitmap(*self, depth);
3603 return bitmap;
3604 }
3605 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3606 wxImage mono = self->ConvertToMono( red, green, blue );
3607 wxBitmap bitmap( mono, 1 );
3608 return bitmap;
3609 }
3610 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3611 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3612 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3613 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3614 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3616 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3617 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3618 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3619 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3620 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3621 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3622 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3623 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3624 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3625
3626 #include <wx/quantize.h>
3627
3628 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3629 return wxQuantize::Quantize(src, dest,
3630 //NULL, // palette
3631 desiredNoColours,
3632 NULL, // eightBitData
3633 flags);
3634 }
3635 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3636 if (PyCallable_Check(func)) {
3637 self->Connect(id, lastId, eventType,
3638 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3639 new wxPyCallback(func));
3640 }
3641 else if (func == Py_None) {
3642 self->Disconnect(id, lastId, eventType,
3643 (wxObjectEventFunction)
3644 &wxPyCallback::EventThunker);
3645 }
3646 else {
3647 wxPyBLOCK_THREADS(
3648 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3649 }
3650 }
3651 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3652 return self->Disconnect(id, lastId, eventType,
3653 (wxObjectEventFunction)
3654 &wxPyCallback::EventThunker);
3655 }
3656 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3657 if (_self && _self != Py_None) {
3658 self->SetClientObject(new wxPyOORClientData(_self, incref));
3659 }
3660 else {
3661 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3662 if (data) {
3663 self->SetClientObject(NULL); // This will delete it too
3664 }
3665 }
3666 }
3667
3668 #if ! wxUSE_HOTKEY
3669 #define wxEVT_HOTKEY -9999
3670 #endif
3671
3672 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3673 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3674 if (data) {
3675 Py_INCREF(data->m_obj);
3676 return data->m_obj;
3677 } else {
3678 Py_INCREF(Py_None);
3679 return Py_None;
3680 }
3681 }
3682 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3683 wxPyClientData* data = new wxPyClientData(clientData);
3684 self->SetClientObject(data);
3685 }
3686 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3687 #if wxUSE_UNICODE
3688 return self->GetUnicodeKey();
3689 #else
3690 return 0;
3691 #endif
3692 }
3693
3694 SWIGINTERNINLINE PyObject *
3695 SWIG_From_unsigned_SS_int (unsigned int value)
3696 {
3697 return SWIG_From_unsigned_SS_long (value);
3698 }
3699
3700
3701 SWIGINTERN int
3702 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3703 {
3704 unsigned long v;
3705 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3706 if (SWIG_IsOK(res)) {
3707 if ((v > UINT_MAX)) {
3708 return SWIG_OverflowError;
3709 } else {
3710 if (val) *val = static_cast< unsigned int >(v);
3711 }
3712 }
3713 return res;
3714 }
3715
3716 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3717 self->m_size = size;
3718 }
3719 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3720 int count = self->GetNumberOfFiles();
3721 wxString* files = self->GetFiles();
3722 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3723 PyObject* list = PyList_New(count);
3724
3725 if (!list) {
3726 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3727 wxPyEndBlockThreads(blocked);
3728 return NULL;
3729 }
3730
3731 for (int i=0; i<count; i++) {
3732 PyList_SetItem(list, i, wx2PyString(files[i]));
3733 }
3734 wxPyEndBlockThreads(blocked);
3735 return list;
3736 }
3737
3738
3739 SWIGINTERN wxPyApp *new_wxPyApp(){
3740 wxPythonApp = new wxPyApp();
3741 return wxPythonApp;
3742 }
3743 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3744
3745 void wxApp_CleanUp() {
3746 __wxPyCleanup();
3747 }
3748
3749
3750 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3751
3752
3753
3754
3755
3756 SWIGINTERNINLINE PyObject *
3757 SWIG_FromCharPtr(const char *cptr)
3758 {
3759 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3760 }
3761
3762
3763 #if 0 // #ifdef __WXMAC__
3764
3765 // A dummy class that raises an exception if used...
3766 class wxEventLoop
3767 {
3768 public:
3769 wxEventLoop() { wxPyRaiseNotImplemented(); }
3770 int Run() { return 0; }
3771 void Exit(int rc = 0) {}
3772 bool Pending() const { return false; }
3773 bool Dispatch() { return false; }
3774 bool IsRunning() const { return false; }
3775 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3776 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3777 };
3778
3779 #else
3780
3781 #include <wx/evtloop.h>
3782
3783 #endif
3784
3785
3786
3787 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3788 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3789 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3790 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3791 wxWindowList& list = self->GetChildren();
3792 return wxPy_ConvertList(&list);
3793 }
3794 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3795 #if wxUSE_HOTKEY
3796 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3797 #else
3798 return false;
3799 #endif
3800 }
3801 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3802
3803
3804
3805 return false;
3806
3807 }
3808 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3809 return wxPyGetWinHandle(self);
3810 }
3811 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3812 self->AssociateHandle((WXWidget)handle);
3813 }
3814 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3815
3816 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3817 return wxWindow::FindWindowById(id, parent);
3818 }
3819
3820 wxWindow* wxFindWindowByName( const wxString& name,
3821 const wxWindow *parent = NULL ) {
3822 return wxWindow::FindWindowByName(name, parent);
3823 }
3824
3825 wxWindow* wxFindWindowByLabel( const wxString& label,
3826 const wxWindow *parent = NULL ) {
3827 return wxWindow::FindWindowByLabel(label, parent);
3828 }
3829
3830
3831 #ifdef __WXMSW__
3832 #include <wx/msw/private.h> // to get wxGetWindowId
3833 #endif
3834
3835
3836 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3837 #ifdef __WXMSW__
3838 WXHWND hWnd = (WXHWND)_hWnd;
3839 long id = wxGetWindowId(hWnd);
3840 wxWindow* win = new wxWindow;
3841 if (parent)
3842 parent->AddChild(win);
3843 win->SetEventHandler(win);
3844 win->SetHWND(hWnd);
3845 win->SetId(id);
3846 win->SubclassWin(hWnd);
3847 win->AdoptAttributesFromHWND();
3848 win->SetupColours();
3849 return win;
3850 #else
3851 wxPyRaiseNotImplemented();
3852 return NULL;
3853 #endif
3854 }
3855
3856
3857 PyObject* GetTopLevelWindows() {
3858 return wxPy_ConvertList(&wxTopLevelWindows);
3859 }
3860
3861
3862 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3863 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3864 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3865
3866 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3867
3868
3869 SWIGINTERNINLINE int
3870 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3871 {
3872 unsigned long v;
3873 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3874 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3875 return res;
3876 }
3877
3878 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3879 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3880 wxMenuItemList& list = self->GetMenuItems();
3881 return wxPy_ConvertList(&list);
3882 }
3883 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3884 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3885 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3886 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3887 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3888 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3889 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3890 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3891 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3892 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3893 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3894 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3895 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3896 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3897 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3898 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3899 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3900 static const wxString wxPyControlNameStr(wxControlNameStr);
3901 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3902 if (clientData) {
3903 wxPyClientData* data = new wxPyClientData(clientData);
3904 return self->Append(item, data);
3905 } else
3906 return self->Append(item);
3907 }
3908 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3909 if (clientData) {
3910 wxPyClientData* data = new wxPyClientData(clientData);
3911 return self->Insert(item, pos, data);
3912 } else
3913 return self->Insert(item, pos);
3914 }
3915 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3916 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3917 if (data) {
3918 Py_INCREF(data->m_obj);
3919 return data->m_obj;
3920 } else {
3921 Py_INCREF(Py_None);
3922 return Py_None;
3923 }
3924 }
3925 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3926 wxPyClientData* data = new wxPyClientData(clientData);
3927 self->SetClientObject(n, data);
3928 }
3929
3930
3931 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3932 wxPyUserData* data = NULL;
3933 if ( userData ) {
3934 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3935 data = new wxPyUserData(userData);
3936 wxPyEndBlockThreads(blocked);
3937 }
3938 return new wxSizerItem(window, proportion, flag, border, data);
3939 }
3940 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3941 wxPyUserData* data = NULL;
3942 if ( userData ) {
3943 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3944 data = new wxPyUserData(userData);
3945 wxPyEndBlockThreads(blocked);
3946 }
3947 return new wxSizerItem(width, height, proportion, flag, border, data);
3948 }
3949 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3950 wxPyUserData* data = NULL;
3951 if ( userData ) {
3952 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3953 data = new wxPyUserData(userData);
3954 wxPyEndBlockThreads(blocked);
3955 }
3956 return new wxSizerItem(sizer, proportion, flag, border, data);
3957 }
3958
3959 #include <float.h>
3960
3961
3962 SWIGINTERN int
3963 SWIG_AsVal_float (PyObject * obj, float *val)
3964 {
3965 double v;
3966 int res = SWIG_AsVal_double (obj, &v);
3967 if (SWIG_IsOK(res)) {
3968 if ((v < -FLT_MAX || v > FLT_MAX)) {
3969 return SWIG_OverflowError;
3970 } else {
3971 if (val) *val = static_cast< float >(v);
3972 }
3973 }
3974 return res;
3975 }
3976
3977
3978 SWIGINTERNINLINE PyObject *
3979 SWIG_From_float (float value)
3980 {
3981 return SWIG_From_double (value);
3982 }
3983
3984 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3985 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3986 if (data) {
3987 Py_INCREF(data->m_obj);
3988 return data->m_obj;
3989 } else {
3990 Py_INCREF(Py_None);
3991 return Py_None;
3992 }
3993 }
3994 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3995 wxPyUserData* data = NULL;
3996 if ( userData ) {
3997 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3998 data = new wxPyUserData(userData);
3999 wxPyEndBlockThreads(blocked);
4000 }
4001 self->SetUserData(data);
4002 }
4003
4004 // Figure out the type of the sizer item
4005
4006 struct wxPySizerItemInfo {
4007 wxPySizerItemInfo()
4008 : window(NULL), sizer(NULL), gotSize(false),
4009 size(wxDefaultSize), gotPos(false), pos(-1)
4010 {}
4011
4012 wxWindow* window;
4013 wxSizer* sizer;
4014 bool gotSize;
4015 wxSize size;
4016 bool gotPos;
4017 int pos;
4018 };
4019
4020 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4021
4022 wxPySizerItemInfo info;
4023 wxSize size;
4024 wxSize* sizePtr = &size;
4025
4026 // Find out what the type of the item is
4027 // try wxWindow
4028 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4029 PyErr_Clear();
4030 info.window = NULL;
4031
4032 // try wxSizer
4033 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4034 PyErr_Clear();
4035 info.sizer = NULL;
4036
4037 // try wxSize or (w,h)
4038 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4039 info.size = *sizePtr;
4040 info.gotSize = true;
4041 }
4042
4043 // or a single int
4044 if (checkIdx && PyInt_Check(item)) {
4045 info.pos = PyInt_AsLong(item);
4046 info.gotPos = true;
4047 }
4048 }
4049 }
4050
4051 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4052 // no expected type, figure out what kind of error message to generate
4053 if ( !checkSize && !checkIdx )
4054 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4055 else if ( checkSize && !checkIdx )
4056 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4057 else if ( !checkSize && checkIdx)
4058 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4059 else
4060 // can this one happen?
4061 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4062 }
4063
4064 return info;
4065 }
4066
4067 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4068 if (!self->GetClientObject())
4069 self->SetClientObject(new wxPyOORClientData(_self));
4070 }
4071 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4072
4073 wxPyUserData* data = NULL;
4074 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4075 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4076 if ( userData && (info.window || info.sizer || info.gotSize) )
4077 data = new wxPyUserData(userData);
4078 if ( info.sizer )
4079 PyObject_SetAttrString(item,"thisown",Py_False);
4080 wxPyEndBlockThreads(blocked);
4081
4082 // Now call the real Add method if a valid item type was found
4083 if ( info.window )
4084 return self->Add(info.window, proportion, flag, border, data);
4085 else if ( info.sizer )
4086 return self->Add(info.sizer, proportion, flag, border, data);
4087 else if (info.gotSize)
4088 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4089 proportion, flag, border, data);
4090 else
4091 return NULL;
4092 }
4093 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4094
4095 wxPyUserData* data = NULL;
4096 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4097 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4098 if ( userData && (info.window || info.sizer || info.gotSize) )
4099 data = new wxPyUserData(userData);
4100 if ( info.sizer )
4101 PyObject_SetAttrString(item,"thisown",Py_False);
4102 wxPyEndBlockThreads(blocked);
4103
4104 // Now call the real Insert method if a valid item type was found
4105 if ( info.window )
4106 return self->Insert(before, info.window, proportion, flag, border, data);
4107 else if ( info.sizer )
4108 return self->Insert(before, info.sizer, proportion, flag, border, data);
4109 else if (info.gotSize)
4110 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4111 proportion, flag, border, data);
4112 else
4113 return NULL;
4114 }
4115 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4116
4117 wxPyUserData* data = NULL;
4118 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4119 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4120 if ( userData && (info.window || info.sizer || info.gotSize) )
4121 data = new wxPyUserData(userData);
4122 if ( info.sizer )
4123 PyObject_SetAttrString(item,"thisown",Py_False);
4124 wxPyEndBlockThreads(blocked);
4125
4126 // Now call the real Prepend method if a valid item type was found
4127 if ( info.window )
4128 return self->Prepend(info.window, proportion, flag, border, data);
4129 else if ( info.sizer )
4130 return self->Prepend(info.sizer, proportion, flag, border, data);
4131 else if (info.gotSize)
4132 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4133 proportion, flag, border, data);
4134 else
4135 return NULL;
4136 }
4137 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4138 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4139 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4140 wxPyEndBlockThreads(blocked);
4141 if ( info.window )
4142 return self->Remove(info.window);
4143 else if ( info.sizer )
4144 return self->Remove(info.sizer);
4145 else if ( info.gotPos )
4146 return self->Remove(info.pos);
4147 else
4148 return false;
4149 }
4150 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4151 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4152 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4153 wxPyEndBlockThreads(blocked);
4154 if ( info.window )
4155 return self->Detach(info.window);
4156 else if ( info.sizer )
4157 return self->Detach(info.sizer);
4158 else if ( info.gotPos )
4159 return self->Detach(info.pos);
4160 else
4161 return false;
4162 }
4163 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4164 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4165 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4166 wxPyEndBlockThreads(blocked);
4167 if ( info.window )
4168 return self->GetItem(info.window);
4169 else if ( info.sizer )
4170 return self->GetItem(info.sizer);
4171 else if ( info.gotPos )
4172 return self->GetItem(info.pos);
4173 else
4174 return NULL;
4175 }
4176 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4177 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4178 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4179 wxPyEndBlockThreads(blocked);
4180 if ( info.window )
4181 self->SetItemMinSize(info.window, size);
4182 else if ( info.sizer )
4183 self->SetItemMinSize(info.sizer, size);
4184 else if ( info.gotPos )
4185 self->SetItemMinSize(info.pos, size);
4186 }
4187 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4188 wxSizerItemList& list = self->GetChildren();
4189 return wxPy_ConvertList(&list);
4190 }
4191 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4192 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4193 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4194 wxPyEndBlockThreads(blocked);
4195 if ( info.window )
4196 return self->Show(info.window, show, recursive);
4197 else if ( info.sizer )
4198 return self->Show(info.sizer, show, recursive);
4199 else if ( info.gotPos )
4200 return self->Show(info.pos, show);
4201 else
4202 return false;
4203 }
4204 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4205 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4206 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4207 wxPyEndBlockThreads(blocked);
4208 if ( info.window )
4209 return self->IsShown(info.window);
4210 else if ( info.sizer )
4211 return self->IsShown(info.sizer);
4212 else if ( info.gotPos )
4213 return self->IsShown(info.pos);
4214 else
4215 return false;
4216 }
4217
4218 // See pyclasses.h
4219 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4220 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4221 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4222
4223
4224
4225
4226 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4227 {
4228 if (source == Py_None) {
4229 **obj = wxGBPosition(-1,-1);
4230 return true;
4231 }
4232 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4233 }
4234
4235 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4236 {
4237 if (source == Py_None) {
4238 **obj = wxGBSpan(-1,-1);
4239 return true;
4240 }
4241 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4242 }
4243
4244
4245 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4246 wxGBPosition temp, *obj = &temp;
4247 if ( other == Py_None ) return false;
4248 if ( ! wxGBPosition_helper(other, &obj) ) {
4249 PyErr_Clear();
4250 return false;
4251 }
4252 return self->operator==(*obj);
4253 }
4254 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4255 wxGBPosition temp, *obj = &temp;
4256 if ( other == Py_None ) return true;
4257 if ( ! wxGBPosition_helper(other, &obj)) {
4258 PyErr_Clear();
4259 return true;
4260 }
4261 return self->operator!=(*obj);
4262 }
4263 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4264 self->SetRow(row);
4265 self->SetCol(col);
4266 }
4267 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4268 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4269 PyObject* tup = PyTuple_New(2);
4270 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4271 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4272 wxPyEndBlockThreads(blocked);
4273 return tup;
4274 }
4275 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4276 wxGBSpan temp, *obj = &temp;
4277 if ( other == Py_None ) return false;
4278 if ( ! wxGBSpan_helper(other, &obj) ) {
4279 PyErr_Clear();
4280 return false;
4281 }
4282 return self->operator==(*obj);
4283 }
4284 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4285 wxGBSpan temp, *obj = &temp;
4286 if ( other == Py_None ) return true;
4287 if ( ! wxGBSpan_helper(other, &obj)) {
4288 PyErr_Clear();
4289 return true;
4290 }
4291 return self->operator!=(*obj);
4292 }
4293 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4294 self->SetRowspan(rowspan);
4295 self->SetColspan(colspan);
4296 }
4297 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 PyObject* tup = PyTuple_New(2);
4300 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4301 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4302 wxPyEndBlockThreads(blocked);
4303 return tup;
4304 }
4305 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4306 wxPyUserData* data = NULL;
4307 if ( userData ) {
4308 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4309 data = new wxPyUserData(userData);
4310 wxPyEndBlockThreads(blocked);
4311 }
4312 return new wxGBSizerItem(window, pos, span, flag, border, data);
4313 }
4314 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4315 wxPyUserData* data = NULL;
4316 if ( userData ) {
4317 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4318 data = new wxPyUserData(userData);
4319 wxPyEndBlockThreads(blocked);
4320 }
4321 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4322 }
4323 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4324 wxPyUserData* data = NULL;
4325 if ( userData ) {
4326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4327 data = new wxPyUserData(userData);
4328 wxPyEndBlockThreads(blocked);
4329 }
4330 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4331 }
4332 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4333 int row, col;
4334 self->GetEndPos(row, col);
4335 return wxGBPosition(row, col);
4336 }
4337 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4338
4339 wxPyUserData* data = NULL;
4340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4341 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4342 if ( userData && (info.window || info.sizer || info.gotSize) )
4343 data = new wxPyUserData(userData);
4344 if ( info.sizer )
4345 PyObject_SetAttrString(item,"thisown",Py_False);
4346 wxPyEndBlockThreads(blocked);
4347
4348 // Now call the real Add method if a valid item type was found
4349 if ( info.window )
4350 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4351 else if ( info.sizer )
4352 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4353 else if (info.gotSize)
4354 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4355 pos, span, flag, border, data);
4356 return NULL;
4357 }
4358
4359
4360 #ifdef __cplusplus
4361 extern "C" {
4362 #endif
4363 SWIGINTERN int EmptyString_set(PyObject *) {
4364 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4365 return 1;
4366 }
4367
4368
4369 SWIGINTERN PyObject *EmptyString_get(void) {
4370 PyObject *pyobj = 0;
4371
4372 {
4373 #if wxUSE_UNICODE
4374 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4375 #else
4376 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4377 #endif
4378 }
4379 return pyobj;
4380 }
4381
4382
4383 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4384 PyObject *resultobj = 0;
4385 wxObject *arg1 = (wxObject *) 0 ;
4386 wxString result;
4387 void *argp1 = 0 ;
4388 int res1 = 0 ;
4389 PyObject *swig_obj[1] ;
4390
4391 if (!args) SWIG_fail;
4392 swig_obj[0] = args;
4393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4394 if (!SWIG_IsOK(res1)) {
4395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4396 }
4397 arg1 = reinterpret_cast< wxObject * >(argp1);
4398 {
4399 PyThreadState* __tstate = wxPyBeginAllowThreads();
4400 result = wxObject_GetClassName(arg1);
4401 wxPyEndAllowThreads(__tstate);
4402 if (PyErr_Occurred()) SWIG_fail;
4403 }
4404 {
4405 #if wxUSE_UNICODE
4406 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4407 #else
4408 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4409 #endif
4410 }
4411 return resultobj;
4412 fail:
4413 return NULL;
4414 }
4415
4416
4417 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4418 PyObject *resultobj = 0;
4419 wxObject *arg1 = (wxObject *) 0 ;
4420 void *argp1 = 0 ;
4421 int res1 = 0 ;
4422 PyObject *swig_obj[1] ;
4423
4424 if (!args) SWIG_fail;
4425 swig_obj[0] = args;
4426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4427 if (!SWIG_IsOK(res1)) {
4428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4429 }
4430 arg1 = reinterpret_cast< wxObject * >(argp1);
4431 {
4432 PyThreadState* __tstate = wxPyBeginAllowThreads();
4433 wxObject_Destroy(arg1);
4434 wxPyEndAllowThreads(__tstate);
4435 if (PyErr_Occurred()) SWIG_fail;
4436 }
4437 resultobj = SWIG_Py_Void();
4438 return resultobj;
4439 fail:
4440 return NULL;
4441 }
4442
4443
4444 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4445 PyObject *obj;
4446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4447 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4448 return SWIG_Py_Void();
4449 }
4450
4451 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4452 PyObject *resultobj = 0;
4453 wxSize *arg1 = (wxSize *) 0 ;
4454 int arg2 ;
4455 void *argp1 = 0 ;
4456 int res1 = 0 ;
4457 int val2 ;
4458 int ecode2 = 0 ;
4459 PyObject *swig_obj[2] ;
4460
4461 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4463 if (!SWIG_IsOK(res1)) {
4464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4465 }
4466 arg1 = reinterpret_cast< wxSize * >(argp1);
4467 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4468 if (!SWIG_IsOK(ecode2)) {
4469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4470 }
4471 arg2 = static_cast< int >(val2);
4472 if (arg1) (arg1)->x = arg2;
4473
4474 resultobj = SWIG_Py_Void();
4475 return resultobj;
4476 fail:
4477 return NULL;
4478 }
4479
4480
4481 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4482 PyObject *resultobj = 0;
4483 wxSize *arg1 = (wxSize *) 0 ;
4484 int result;
4485 void *argp1 = 0 ;
4486 int res1 = 0 ;
4487 PyObject *swig_obj[1] ;
4488
4489 if (!args) SWIG_fail;
4490 swig_obj[0] = args;
4491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4492 if (!SWIG_IsOK(res1)) {
4493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4494 }
4495 arg1 = reinterpret_cast< wxSize * >(argp1);
4496 result = (int) ((arg1)->x);
4497 resultobj = SWIG_From_int(static_cast< int >(result));
4498 return resultobj;
4499 fail:
4500 return NULL;
4501 }
4502
4503
4504 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4505 PyObject *resultobj = 0;
4506 wxSize *arg1 = (wxSize *) 0 ;
4507 int arg2 ;
4508 void *argp1 = 0 ;
4509 int res1 = 0 ;
4510 int val2 ;
4511 int ecode2 = 0 ;
4512 PyObject *swig_obj[2] ;
4513
4514 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4516 if (!SWIG_IsOK(res1)) {
4517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4518 }
4519 arg1 = reinterpret_cast< wxSize * >(argp1);
4520 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4521 if (!SWIG_IsOK(ecode2)) {
4522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4523 }
4524 arg2 = static_cast< int >(val2);
4525 if (arg1) (arg1)->y = arg2;
4526
4527 resultobj = SWIG_Py_Void();
4528 return resultobj;
4529 fail:
4530 return NULL;
4531 }
4532
4533
4534 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4535 PyObject *resultobj = 0;
4536 wxSize *arg1 = (wxSize *) 0 ;
4537 int result;
4538 void *argp1 = 0 ;
4539 int res1 = 0 ;
4540 PyObject *swig_obj[1] ;
4541
4542 if (!args) SWIG_fail;
4543 swig_obj[0] = args;
4544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4545 if (!SWIG_IsOK(res1)) {
4546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4547 }
4548 arg1 = reinterpret_cast< wxSize * >(argp1);
4549 result = (int) ((arg1)->y);
4550 resultobj = SWIG_From_int(static_cast< int >(result));
4551 return resultobj;
4552 fail:
4553 return NULL;
4554 }
4555
4556
4557 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4558 PyObject *resultobj = 0;
4559 int arg1 = (int) 0 ;
4560 int arg2 = (int) 0 ;
4561 wxSize *result = 0 ;
4562 int val1 ;
4563 int ecode1 = 0 ;
4564 int val2 ;
4565 int ecode2 = 0 ;
4566 PyObject * obj0 = 0 ;
4567 PyObject * obj1 = 0 ;
4568 char * kwnames[] = {
4569 (char *) "w",(char *) "h", NULL
4570 };
4571
4572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4573 if (obj0) {
4574 ecode1 = SWIG_AsVal_int(obj0, &val1);
4575 if (!SWIG_IsOK(ecode1)) {
4576 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4577 }
4578 arg1 = static_cast< int >(val1);
4579 }
4580 if (obj1) {
4581 ecode2 = SWIG_AsVal_int(obj1, &val2);
4582 if (!SWIG_IsOK(ecode2)) {
4583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4584 }
4585 arg2 = static_cast< int >(val2);
4586 }
4587 {
4588 PyThreadState* __tstate = wxPyBeginAllowThreads();
4589 result = (wxSize *)new wxSize(arg1,arg2);
4590 wxPyEndAllowThreads(__tstate);
4591 if (PyErr_Occurred()) SWIG_fail;
4592 }
4593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4594 return resultobj;
4595 fail:
4596 return NULL;
4597 }
4598
4599
4600 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4601 PyObject *resultobj = 0;
4602 wxSize *arg1 = (wxSize *) 0 ;
4603 void *argp1 = 0 ;
4604 int res1 = 0 ;
4605 PyObject *swig_obj[1] ;
4606
4607 if (!args) SWIG_fail;
4608 swig_obj[0] = args;
4609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4610 if (!SWIG_IsOK(res1)) {
4611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4612 }
4613 arg1 = reinterpret_cast< wxSize * >(argp1);
4614 {
4615 PyThreadState* __tstate = wxPyBeginAllowThreads();
4616 delete arg1;
4617
4618 wxPyEndAllowThreads(__tstate);
4619 if (PyErr_Occurred()) SWIG_fail;
4620 }
4621 resultobj = SWIG_Py_Void();
4622 return resultobj;
4623 fail:
4624 return NULL;
4625 }
4626
4627
4628 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4629 PyObject *resultobj = 0;
4630 wxSize *arg1 = (wxSize *) 0 ;
4631 PyObject *arg2 = (PyObject *) 0 ;
4632 bool result;
4633 void *argp1 = 0 ;
4634 int res1 = 0 ;
4635 PyObject * obj0 = 0 ;
4636 PyObject * obj1 = 0 ;
4637 char * kwnames[] = {
4638 (char *) "self",(char *) "other", NULL
4639 };
4640
4641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4643 if (!SWIG_IsOK(res1)) {
4644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4645 }
4646 arg1 = reinterpret_cast< wxSize * >(argp1);
4647 arg2 = obj1;
4648 {
4649 result = (bool)wxSize___eq__(arg1,arg2);
4650 if (PyErr_Occurred()) SWIG_fail;
4651 }
4652 {
4653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4654 }
4655 return resultobj;
4656 fail:
4657 return NULL;
4658 }
4659
4660
4661 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4662 PyObject *resultobj = 0;
4663 wxSize *arg1 = (wxSize *) 0 ;
4664 PyObject *arg2 = (PyObject *) 0 ;
4665 bool result;
4666 void *argp1 = 0 ;
4667 int res1 = 0 ;
4668 PyObject * obj0 = 0 ;
4669 PyObject * obj1 = 0 ;
4670 char * kwnames[] = {
4671 (char *) "self",(char *) "other", NULL
4672 };
4673
4674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4676 if (!SWIG_IsOK(res1)) {
4677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4678 }
4679 arg1 = reinterpret_cast< wxSize * >(argp1);
4680 arg2 = obj1;
4681 {
4682 result = (bool)wxSize___ne__(arg1,arg2);
4683 if (PyErr_Occurred()) SWIG_fail;
4684 }
4685 {
4686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4687 }
4688 return resultobj;
4689 fail:
4690 return NULL;
4691 }
4692
4693
4694 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4695 PyObject *resultobj = 0;
4696 wxSize *arg1 = (wxSize *) 0 ;
4697 wxSize *arg2 = 0 ;
4698 wxSize result;
4699 void *argp1 = 0 ;
4700 int res1 = 0 ;
4701 wxSize temp2 ;
4702 PyObject * obj0 = 0 ;
4703 PyObject * obj1 = 0 ;
4704 char * kwnames[] = {
4705 (char *) "self",(char *) "sz", NULL
4706 };
4707
4708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4710 if (!SWIG_IsOK(res1)) {
4711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4712 }
4713 arg1 = reinterpret_cast< wxSize * >(argp1);
4714 {
4715 arg2 = &temp2;
4716 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4717 }
4718 {
4719 PyThreadState* __tstate = wxPyBeginAllowThreads();
4720 result = (arg1)->operator +((wxSize const &)*arg2);
4721 wxPyEndAllowThreads(__tstate);
4722 if (PyErr_Occurred()) SWIG_fail;
4723 }
4724 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4725 return resultobj;
4726 fail:
4727 return NULL;
4728 }
4729
4730
4731 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4732 PyObject *resultobj = 0;
4733 wxSize *arg1 = (wxSize *) 0 ;
4734 wxSize *arg2 = 0 ;
4735 wxSize result;
4736 void *argp1 = 0 ;
4737 int res1 = 0 ;
4738 wxSize temp2 ;
4739 PyObject * obj0 = 0 ;
4740 PyObject * obj1 = 0 ;
4741 char * kwnames[] = {
4742 (char *) "self",(char *) "sz", NULL
4743 };
4744
4745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4747 if (!SWIG_IsOK(res1)) {
4748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4749 }
4750 arg1 = reinterpret_cast< wxSize * >(argp1);
4751 {
4752 arg2 = &temp2;
4753 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4754 }
4755 {
4756 PyThreadState* __tstate = wxPyBeginAllowThreads();
4757 result = (arg1)->operator -((wxSize const &)*arg2);
4758 wxPyEndAllowThreads(__tstate);
4759 if (PyErr_Occurred()) SWIG_fail;
4760 }
4761 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4762 return resultobj;
4763 fail:
4764 return NULL;
4765 }
4766
4767
4768 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4769 PyObject *resultobj = 0;
4770 wxSize *arg1 = (wxSize *) 0 ;
4771 wxSize *arg2 = 0 ;
4772 void *argp1 = 0 ;
4773 int res1 = 0 ;
4774 wxSize temp2 ;
4775 PyObject * obj0 = 0 ;
4776 PyObject * obj1 = 0 ;
4777 char * kwnames[] = {
4778 (char *) "self",(char *) "sz", NULL
4779 };
4780
4781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4783 if (!SWIG_IsOK(res1)) {
4784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4785 }
4786 arg1 = reinterpret_cast< wxSize * >(argp1);
4787 {
4788 arg2 = &temp2;
4789 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4790 }
4791 {
4792 PyThreadState* __tstate = wxPyBeginAllowThreads();
4793 (arg1)->IncTo((wxSize const &)*arg2);
4794 wxPyEndAllowThreads(__tstate);
4795 if (PyErr_Occurred()) SWIG_fail;
4796 }
4797 resultobj = SWIG_Py_Void();
4798 return resultobj;
4799 fail:
4800 return NULL;
4801 }
4802
4803
4804 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4805 PyObject *resultobj = 0;
4806 wxSize *arg1 = (wxSize *) 0 ;
4807 wxSize *arg2 = 0 ;
4808 void *argp1 = 0 ;
4809 int res1 = 0 ;
4810 wxSize temp2 ;
4811 PyObject * obj0 = 0 ;
4812 PyObject * obj1 = 0 ;
4813 char * kwnames[] = {
4814 (char *) "self",(char *) "sz", NULL
4815 };
4816
4817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4819 if (!SWIG_IsOK(res1)) {
4820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4821 }
4822 arg1 = reinterpret_cast< wxSize * >(argp1);
4823 {
4824 arg2 = &temp2;
4825 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4826 }
4827 {
4828 PyThreadState* __tstate = wxPyBeginAllowThreads();
4829 (arg1)->DecTo((wxSize const &)*arg2);
4830 wxPyEndAllowThreads(__tstate);
4831 if (PyErr_Occurred()) SWIG_fail;
4832 }
4833 resultobj = SWIG_Py_Void();
4834 return resultobj;
4835 fail:
4836 return NULL;
4837 }
4838
4839
4840 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4841 PyObject *resultobj = 0;
4842 wxSize *arg1 = (wxSize *) 0 ;
4843 int arg2 ;
4844 int arg3 ;
4845 void *argp1 = 0 ;
4846 int res1 = 0 ;
4847 int val2 ;
4848 int ecode2 = 0 ;
4849 int val3 ;
4850 int ecode3 = 0 ;
4851 PyObject * obj0 = 0 ;
4852 PyObject * obj1 = 0 ;
4853 PyObject * obj2 = 0 ;
4854 char * kwnames[] = {
4855 (char *) "self",(char *) "w",(char *) "h", NULL
4856 };
4857
4858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4860 if (!SWIG_IsOK(res1)) {
4861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4862 }
4863 arg1 = reinterpret_cast< wxSize * >(argp1);
4864 ecode2 = SWIG_AsVal_int(obj1, &val2);
4865 if (!SWIG_IsOK(ecode2)) {
4866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4867 }
4868 arg2 = static_cast< int >(val2);
4869 ecode3 = SWIG_AsVal_int(obj2, &val3);
4870 if (!SWIG_IsOK(ecode3)) {
4871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4872 }
4873 arg3 = static_cast< int >(val3);
4874 {
4875 PyThreadState* __tstate = wxPyBeginAllowThreads();
4876 (arg1)->Set(arg2,arg3);
4877 wxPyEndAllowThreads(__tstate);
4878 if (PyErr_Occurred()) SWIG_fail;
4879 }
4880 resultobj = SWIG_Py_Void();
4881 return resultobj;
4882 fail:
4883 return NULL;
4884 }
4885
4886
4887 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4888 PyObject *resultobj = 0;
4889 wxSize *arg1 = (wxSize *) 0 ;
4890 int arg2 ;
4891 void *argp1 = 0 ;
4892 int res1 = 0 ;
4893 int val2 ;
4894 int ecode2 = 0 ;
4895 PyObject * obj0 = 0 ;
4896 PyObject * obj1 = 0 ;
4897 char * kwnames[] = {
4898 (char *) "self",(char *) "w", NULL
4899 };
4900
4901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4903 if (!SWIG_IsOK(res1)) {
4904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4905 }
4906 arg1 = reinterpret_cast< wxSize * >(argp1);
4907 ecode2 = SWIG_AsVal_int(obj1, &val2);
4908 if (!SWIG_IsOK(ecode2)) {
4909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4910 }
4911 arg2 = static_cast< int >(val2);
4912 {
4913 PyThreadState* __tstate = wxPyBeginAllowThreads();
4914 (arg1)->SetWidth(arg2);
4915 wxPyEndAllowThreads(__tstate);
4916 if (PyErr_Occurred()) SWIG_fail;
4917 }
4918 resultobj = SWIG_Py_Void();
4919 return resultobj;
4920 fail:
4921 return NULL;
4922 }
4923
4924
4925 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4926 PyObject *resultobj = 0;
4927 wxSize *arg1 = (wxSize *) 0 ;
4928 int arg2 ;
4929 void *argp1 = 0 ;
4930 int res1 = 0 ;
4931 int val2 ;
4932 int ecode2 = 0 ;
4933 PyObject * obj0 = 0 ;
4934 PyObject * obj1 = 0 ;
4935 char * kwnames[] = {
4936 (char *) "self",(char *) "h", NULL
4937 };
4938
4939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4941 if (!SWIG_IsOK(res1)) {
4942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4943 }
4944 arg1 = reinterpret_cast< wxSize * >(argp1);
4945 ecode2 = SWIG_AsVal_int(obj1, &val2);
4946 if (!SWIG_IsOK(ecode2)) {
4947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4948 }
4949 arg2 = static_cast< int >(val2);
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 (arg1)->SetHeight(arg2);
4953 wxPyEndAllowThreads(__tstate);
4954 if (PyErr_Occurred()) SWIG_fail;
4955 }
4956 resultobj = SWIG_Py_Void();
4957 return resultobj;
4958 fail:
4959 return NULL;
4960 }
4961
4962
4963 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4964 PyObject *resultobj = 0;
4965 wxSize *arg1 = (wxSize *) 0 ;
4966 int result;
4967 void *argp1 = 0 ;
4968 int res1 = 0 ;
4969 PyObject *swig_obj[1] ;
4970
4971 if (!args) SWIG_fail;
4972 swig_obj[0] = args;
4973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4974 if (!SWIG_IsOK(res1)) {
4975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4976 }
4977 arg1 = reinterpret_cast< wxSize * >(argp1);
4978 {
4979 PyThreadState* __tstate = wxPyBeginAllowThreads();
4980 result = (int)((wxSize const *)arg1)->GetWidth();
4981 wxPyEndAllowThreads(__tstate);
4982 if (PyErr_Occurred()) SWIG_fail;
4983 }
4984 resultobj = SWIG_From_int(static_cast< int >(result));
4985 return resultobj;
4986 fail:
4987 return NULL;
4988 }
4989
4990
4991 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4992 PyObject *resultobj = 0;
4993 wxSize *arg1 = (wxSize *) 0 ;
4994 int result;
4995 void *argp1 = 0 ;
4996 int res1 = 0 ;
4997 PyObject *swig_obj[1] ;
4998
4999 if (!args) SWIG_fail;
5000 swig_obj[0] = args;
5001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5002 if (!SWIG_IsOK(res1)) {
5003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5004 }
5005 arg1 = reinterpret_cast< wxSize * >(argp1);
5006 {
5007 PyThreadState* __tstate = wxPyBeginAllowThreads();
5008 result = (int)((wxSize const *)arg1)->GetHeight();
5009 wxPyEndAllowThreads(__tstate);
5010 if (PyErr_Occurred()) SWIG_fail;
5011 }
5012 resultobj = SWIG_From_int(static_cast< int >(result));
5013 return resultobj;
5014 fail:
5015 return NULL;
5016 }
5017
5018
5019 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5020 PyObject *resultobj = 0;
5021 wxSize *arg1 = (wxSize *) 0 ;
5022 bool result;
5023 void *argp1 = 0 ;
5024 int res1 = 0 ;
5025 PyObject *swig_obj[1] ;
5026
5027 if (!args) SWIG_fail;
5028 swig_obj[0] = args;
5029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5030 if (!SWIG_IsOK(res1)) {
5031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5032 }
5033 arg1 = reinterpret_cast< wxSize * >(argp1);
5034 {
5035 PyThreadState* __tstate = wxPyBeginAllowThreads();
5036 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5037 wxPyEndAllowThreads(__tstate);
5038 if (PyErr_Occurred()) SWIG_fail;
5039 }
5040 {
5041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5042 }
5043 return resultobj;
5044 fail:
5045 return NULL;
5046 }
5047
5048
5049 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5050 PyObject *resultobj = 0;
5051 wxSize *arg1 = (wxSize *) 0 ;
5052 wxSize *arg2 = 0 ;
5053 void *argp1 = 0 ;
5054 int res1 = 0 ;
5055 wxSize temp2 ;
5056 PyObject * obj0 = 0 ;
5057 PyObject * obj1 = 0 ;
5058 char * kwnames[] = {
5059 (char *) "self",(char *) "size", NULL
5060 };
5061
5062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5064 if (!SWIG_IsOK(res1)) {
5065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5066 }
5067 arg1 = reinterpret_cast< wxSize * >(argp1);
5068 {
5069 arg2 = &temp2;
5070 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5071 }
5072 {
5073 PyThreadState* __tstate = wxPyBeginAllowThreads();
5074 (arg1)->SetDefaults((wxSize const &)*arg2);
5075 wxPyEndAllowThreads(__tstate);
5076 if (PyErr_Occurred()) SWIG_fail;
5077 }
5078 resultobj = SWIG_Py_Void();
5079 return resultobj;
5080 fail:
5081 return NULL;
5082 }
5083
5084
5085 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5086 PyObject *resultobj = 0;
5087 wxSize *arg1 = (wxSize *) 0 ;
5088 PyObject *result = 0 ;
5089 void *argp1 = 0 ;
5090 int res1 = 0 ;
5091 PyObject *swig_obj[1] ;
5092
5093 if (!args) SWIG_fail;
5094 swig_obj[0] = args;
5095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5096 if (!SWIG_IsOK(res1)) {
5097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5098 }
5099 arg1 = reinterpret_cast< wxSize * >(argp1);
5100 {
5101 PyThreadState* __tstate = wxPyBeginAllowThreads();
5102 result = (PyObject *)wxSize_Get(arg1);
5103 wxPyEndAllowThreads(__tstate);
5104 if (PyErr_Occurred()) SWIG_fail;
5105 }
5106 resultobj = result;
5107 return resultobj;
5108 fail:
5109 return NULL;
5110 }
5111
5112
5113 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5114 PyObject *obj;
5115 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5116 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5117 return SWIG_Py_Void();
5118 }
5119
5120 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5121 return SWIG_Python_InitShadowInstance(args);
5122 }
5123
5124 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5125 PyObject *resultobj = 0;
5126 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5127 double arg2 ;
5128 void *argp1 = 0 ;
5129 int res1 = 0 ;
5130 double val2 ;
5131 int ecode2 = 0 ;
5132 PyObject *swig_obj[2] ;
5133
5134 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5136 if (!SWIG_IsOK(res1)) {
5137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5138 }
5139 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5140 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5141 if (!SWIG_IsOK(ecode2)) {
5142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5143 }
5144 arg2 = static_cast< double >(val2);
5145 if (arg1) (arg1)->x = arg2;
5146
5147 resultobj = SWIG_Py_Void();
5148 return resultobj;
5149 fail:
5150 return NULL;
5151 }
5152
5153
5154 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5155 PyObject *resultobj = 0;
5156 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5157 double result;
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, 0 | 0 );
5165 if (!SWIG_IsOK(res1)) {
5166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5167 }
5168 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5169 result = (double) ((arg1)->x);
5170 resultobj = SWIG_From_double(static_cast< double >(result));
5171 return resultobj;
5172 fail:
5173 return NULL;
5174 }
5175
5176
5177 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5178 PyObject *resultobj = 0;
5179 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5180 double arg2 ;
5181 void *argp1 = 0 ;
5182 int res1 = 0 ;
5183 double val2 ;
5184 int ecode2 = 0 ;
5185 PyObject *swig_obj[2] ;
5186
5187 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5189 if (!SWIG_IsOK(res1)) {
5190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5191 }
5192 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5193 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5194 if (!SWIG_IsOK(ecode2)) {
5195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5196 }
5197 arg2 = static_cast< double >(val2);
5198 if (arg1) (arg1)->y = arg2;
5199
5200 resultobj = SWIG_Py_Void();
5201 return resultobj;
5202 fail:
5203 return NULL;
5204 }
5205
5206
5207 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5208 PyObject *resultobj = 0;
5209 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5210 double result;
5211 void *argp1 = 0 ;
5212 int res1 = 0 ;
5213 PyObject *swig_obj[1] ;
5214
5215 if (!args) SWIG_fail;
5216 swig_obj[0] = args;
5217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5218 if (!SWIG_IsOK(res1)) {
5219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5220 }
5221 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5222 result = (double) ((arg1)->y);
5223 resultobj = SWIG_From_double(static_cast< double >(result));
5224 return resultobj;
5225 fail:
5226 return NULL;
5227 }
5228
5229
5230 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5231 PyObject *resultobj = 0;
5232 double arg1 = (double) 0.0 ;
5233 double arg2 = (double) 0.0 ;
5234 wxRealPoint *result = 0 ;
5235 double val1 ;
5236 int ecode1 = 0 ;
5237 double val2 ;
5238 int ecode2 = 0 ;
5239 PyObject * obj0 = 0 ;
5240 PyObject * obj1 = 0 ;
5241 char * kwnames[] = {
5242 (char *) "x",(char *) "y", NULL
5243 };
5244
5245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5246 if (obj0) {
5247 ecode1 = SWIG_AsVal_double(obj0, &val1);
5248 if (!SWIG_IsOK(ecode1)) {
5249 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5250 }
5251 arg1 = static_cast< double >(val1);
5252 }
5253 if (obj1) {
5254 ecode2 = SWIG_AsVal_double(obj1, &val2);
5255 if (!SWIG_IsOK(ecode2)) {
5256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5257 }
5258 arg2 = static_cast< double >(val2);
5259 }
5260 {
5261 PyThreadState* __tstate = wxPyBeginAllowThreads();
5262 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5263 wxPyEndAllowThreads(__tstate);
5264 if (PyErr_Occurred()) SWIG_fail;
5265 }
5266 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5267 return resultobj;
5268 fail:
5269 return NULL;
5270 }
5271
5272
5273 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5274 PyObject *resultobj = 0;
5275 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5276 void *argp1 = 0 ;
5277 int res1 = 0 ;
5278 PyObject *swig_obj[1] ;
5279
5280 if (!args) SWIG_fail;
5281 swig_obj[0] = args;
5282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5283 if (!SWIG_IsOK(res1)) {
5284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5285 }
5286 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5287 {
5288 PyThreadState* __tstate = wxPyBeginAllowThreads();
5289 delete arg1;
5290
5291 wxPyEndAllowThreads(__tstate);
5292 if (PyErr_Occurred()) SWIG_fail;
5293 }
5294 resultobj = SWIG_Py_Void();
5295 return resultobj;
5296 fail:
5297 return NULL;
5298 }
5299
5300
5301 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5302 PyObject *resultobj = 0;
5303 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5304 PyObject *arg2 = (PyObject *) 0 ;
5305 bool result;
5306 void *argp1 = 0 ;
5307 int res1 = 0 ;
5308 PyObject * obj0 = 0 ;
5309 PyObject * obj1 = 0 ;
5310 char * kwnames[] = {
5311 (char *) "self",(char *) "other", NULL
5312 };
5313
5314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5316 if (!SWIG_IsOK(res1)) {
5317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5318 }
5319 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5320 arg2 = obj1;
5321 {
5322 result = (bool)wxRealPoint___eq__(arg1,arg2);
5323 if (PyErr_Occurred()) SWIG_fail;
5324 }
5325 {
5326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5327 }
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5335 PyObject *resultobj = 0;
5336 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5337 PyObject *arg2 = (PyObject *) 0 ;
5338 bool result;
5339 void *argp1 = 0 ;
5340 int res1 = 0 ;
5341 PyObject * obj0 = 0 ;
5342 PyObject * obj1 = 0 ;
5343 char * kwnames[] = {
5344 (char *) "self",(char *) "other", NULL
5345 };
5346
5347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5349 if (!SWIG_IsOK(res1)) {
5350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5351 }
5352 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5353 arg2 = obj1;
5354 {
5355 result = (bool)wxRealPoint___ne__(arg1,arg2);
5356 if (PyErr_Occurred()) SWIG_fail;
5357 }
5358 {
5359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5360 }
5361 return resultobj;
5362 fail:
5363 return NULL;
5364 }
5365
5366
5367 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5368 PyObject *resultobj = 0;
5369 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5370 wxRealPoint *arg2 = 0 ;
5371 wxRealPoint result;
5372 void *argp1 = 0 ;
5373 int res1 = 0 ;
5374 wxRealPoint temp2 ;
5375 PyObject * obj0 = 0 ;
5376 PyObject * obj1 = 0 ;
5377 char * kwnames[] = {
5378 (char *) "self",(char *) "pt", NULL
5379 };
5380
5381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5383 if (!SWIG_IsOK(res1)) {
5384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5385 }
5386 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5387 {
5388 arg2 = &temp2;
5389 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5390 }
5391 {
5392 PyThreadState* __tstate = wxPyBeginAllowThreads();
5393 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5394 wxPyEndAllowThreads(__tstate);
5395 if (PyErr_Occurred()) SWIG_fail;
5396 }
5397 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5398 return resultobj;
5399 fail:
5400 return NULL;
5401 }
5402
5403
5404 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5405 PyObject *resultobj = 0;
5406 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5407 wxRealPoint *arg2 = 0 ;
5408 wxRealPoint result;
5409 void *argp1 = 0 ;
5410 int res1 = 0 ;
5411 wxRealPoint temp2 ;
5412 PyObject * obj0 = 0 ;
5413 PyObject * obj1 = 0 ;
5414 char * kwnames[] = {
5415 (char *) "self",(char *) "pt", NULL
5416 };
5417
5418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5420 if (!SWIG_IsOK(res1)) {
5421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5422 }
5423 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5424 {
5425 arg2 = &temp2;
5426 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5427 }
5428 {
5429 PyThreadState* __tstate = wxPyBeginAllowThreads();
5430 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5431 wxPyEndAllowThreads(__tstate);
5432 if (PyErr_Occurred()) SWIG_fail;
5433 }
5434 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5435 return resultobj;
5436 fail:
5437 return NULL;
5438 }
5439
5440
5441 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5442 PyObject *resultobj = 0;
5443 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5444 double arg2 ;
5445 double arg3 ;
5446 void *argp1 = 0 ;
5447 int res1 = 0 ;
5448 double val2 ;
5449 int ecode2 = 0 ;
5450 double val3 ;
5451 int ecode3 = 0 ;
5452 PyObject * obj0 = 0 ;
5453 PyObject * obj1 = 0 ;
5454 PyObject * obj2 = 0 ;
5455 char * kwnames[] = {
5456 (char *) "self",(char *) "x",(char *) "y", NULL
5457 };
5458
5459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5461 if (!SWIG_IsOK(res1)) {
5462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5463 }
5464 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5465 ecode2 = SWIG_AsVal_double(obj1, &val2);
5466 if (!SWIG_IsOK(ecode2)) {
5467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5468 }
5469 arg2 = static_cast< double >(val2);
5470 ecode3 = SWIG_AsVal_double(obj2, &val3);
5471 if (!SWIG_IsOK(ecode3)) {
5472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5473 }
5474 arg3 = static_cast< double >(val3);
5475 {
5476 PyThreadState* __tstate = wxPyBeginAllowThreads();
5477 wxRealPoint_Set(arg1,arg2,arg3);
5478 wxPyEndAllowThreads(__tstate);
5479 if (PyErr_Occurred()) SWIG_fail;
5480 }
5481 resultobj = SWIG_Py_Void();
5482 return resultobj;
5483 fail:
5484 return NULL;
5485 }
5486
5487
5488 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5489 PyObject *resultobj = 0;
5490 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5491 PyObject *result = 0 ;
5492 void *argp1 = 0 ;
5493 int res1 = 0 ;
5494 PyObject *swig_obj[1] ;
5495
5496 if (!args) SWIG_fail;
5497 swig_obj[0] = args;
5498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5499 if (!SWIG_IsOK(res1)) {
5500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5501 }
5502 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5503 {
5504 PyThreadState* __tstate = wxPyBeginAllowThreads();
5505 result = (PyObject *)wxRealPoint_Get(arg1);
5506 wxPyEndAllowThreads(__tstate);
5507 if (PyErr_Occurred()) SWIG_fail;
5508 }
5509 resultobj = result;
5510 return resultobj;
5511 fail:
5512 return NULL;
5513 }
5514
5515
5516 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5517 PyObject *obj;
5518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5519 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5520 return SWIG_Py_Void();
5521 }
5522
5523 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5524 return SWIG_Python_InitShadowInstance(args);
5525 }
5526
5527 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5528 PyObject *resultobj = 0;
5529 wxPoint *arg1 = (wxPoint *) 0 ;
5530 int arg2 ;
5531 void *argp1 = 0 ;
5532 int res1 = 0 ;
5533 int val2 ;
5534 int ecode2 = 0 ;
5535 PyObject *swig_obj[2] ;
5536
5537 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5539 if (!SWIG_IsOK(res1)) {
5540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5541 }
5542 arg1 = reinterpret_cast< wxPoint * >(argp1);
5543 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5544 if (!SWIG_IsOK(ecode2)) {
5545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5546 }
5547 arg2 = static_cast< int >(val2);
5548 if (arg1) (arg1)->x = arg2;
5549
5550 resultobj = SWIG_Py_Void();
5551 return resultobj;
5552 fail:
5553 return NULL;
5554 }
5555
5556
5557 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5558 PyObject *resultobj = 0;
5559 wxPoint *arg1 = (wxPoint *) 0 ;
5560 int result;
5561 void *argp1 = 0 ;
5562 int res1 = 0 ;
5563 PyObject *swig_obj[1] ;
5564
5565 if (!args) SWIG_fail;
5566 swig_obj[0] = args;
5567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5568 if (!SWIG_IsOK(res1)) {
5569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5570 }
5571 arg1 = reinterpret_cast< wxPoint * >(argp1);
5572 result = (int) ((arg1)->x);
5573 resultobj = SWIG_From_int(static_cast< int >(result));
5574 return resultobj;
5575 fail:
5576 return NULL;
5577 }
5578
5579
5580 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5581 PyObject *resultobj = 0;
5582 wxPoint *arg1 = (wxPoint *) 0 ;
5583 int arg2 ;
5584 void *argp1 = 0 ;
5585 int res1 = 0 ;
5586 int val2 ;
5587 int ecode2 = 0 ;
5588 PyObject *swig_obj[2] ;
5589
5590 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5592 if (!SWIG_IsOK(res1)) {
5593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5594 }
5595 arg1 = reinterpret_cast< wxPoint * >(argp1);
5596 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5597 if (!SWIG_IsOK(ecode2)) {
5598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5599 }
5600 arg2 = static_cast< int >(val2);
5601 if (arg1) (arg1)->y = arg2;
5602
5603 resultobj = SWIG_Py_Void();
5604 return resultobj;
5605 fail:
5606 return NULL;
5607 }
5608
5609
5610 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5611 PyObject *resultobj = 0;
5612 wxPoint *arg1 = (wxPoint *) 0 ;
5613 int result;
5614 void *argp1 = 0 ;
5615 int res1 = 0 ;
5616 PyObject *swig_obj[1] ;
5617
5618 if (!args) SWIG_fail;
5619 swig_obj[0] = args;
5620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5621 if (!SWIG_IsOK(res1)) {
5622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5623 }
5624 arg1 = reinterpret_cast< wxPoint * >(argp1);
5625 result = (int) ((arg1)->y);
5626 resultobj = SWIG_From_int(static_cast< int >(result));
5627 return resultobj;
5628 fail:
5629 return NULL;
5630 }
5631
5632
5633 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5634 PyObject *resultobj = 0;
5635 int arg1 = (int) 0 ;
5636 int arg2 = (int) 0 ;
5637 wxPoint *result = 0 ;
5638 int val1 ;
5639 int ecode1 = 0 ;
5640 int val2 ;
5641 int ecode2 = 0 ;
5642 PyObject * obj0 = 0 ;
5643 PyObject * obj1 = 0 ;
5644 char * kwnames[] = {
5645 (char *) "x",(char *) "y", NULL
5646 };
5647
5648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5649 if (obj0) {
5650 ecode1 = SWIG_AsVal_int(obj0, &val1);
5651 if (!SWIG_IsOK(ecode1)) {
5652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5653 }
5654 arg1 = static_cast< int >(val1);
5655 }
5656 if (obj1) {
5657 ecode2 = SWIG_AsVal_int(obj1, &val2);
5658 if (!SWIG_IsOK(ecode2)) {
5659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5660 }
5661 arg2 = static_cast< int >(val2);
5662 }
5663 {
5664 PyThreadState* __tstate = wxPyBeginAllowThreads();
5665 result = (wxPoint *)new wxPoint(arg1,arg2);
5666 wxPyEndAllowThreads(__tstate);
5667 if (PyErr_Occurred()) SWIG_fail;
5668 }
5669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5670 return resultobj;
5671 fail:
5672 return NULL;
5673 }
5674
5675
5676 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5677 PyObject *resultobj = 0;
5678 wxPoint *arg1 = (wxPoint *) 0 ;
5679 void *argp1 = 0 ;
5680 int res1 = 0 ;
5681 PyObject *swig_obj[1] ;
5682
5683 if (!args) SWIG_fail;
5684 swig_obj[0] = args;
5685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5686 if (!SWIG_IsOK(res1)) {
5687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5688 }
5689 arg1 = reinterpret_cast< wxPoint * >(argp1);
5690 {
5691 PyThreadState* __tstate = wxPyBeginAllowThreads();
5692 delete arg1;
5693
5694 wxPyEndAllowThreads(__tstate);
5695 if (PyErr_Occurred()) SWIG_fail;
5696 }
5697 resultobj = SWIG_Py_Void();
5698 return resultobj;
5699 fail:
5700 return NULL;
5701 }
5702
5703
5704 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5705 PyObject *resultobj = 0;
5706 wxPoint *arg1 = (wxPoint *) 0 ;
5707 PyObject *arg2 = (PyObject *) 0 ;
5708 bool result;
5709 void *argp1 = 0 ;
5710 int res1 = 0 ;
5711 PyObject * obj0 = 0 ;
5712 PyObject * obj1 = 0 ;
5713 char * kwnames[] = {
5714 (char *) "self",(char *) "other", NULL
5715 };
5716
5717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5719 if (!SWIG_IsOK(res1)) {
5720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5721 }
5722 arg1 = reinterpret_cast< wxPoint * >(argp1);
5723 arg2 = obj1;
5724 {
5725 result = (bool)wxPoint___eq__(arg1,arg2);
5726 if (PyErr_Occurred()) SWIG_fail;
5727 }
5728 {
5729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5730 }
5731 return resultobj;
5732 fail:
5733 return NULL;
5734 }
5735
5736
5737 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5738 PyObject *resultobj = 0;
5739 wxPoint *arg1 = (wxPoint *) 0 ;
5740 PyObject *arg2 = (PyObject *) 0 ;
5741 bool result;
5742 void *argp1 = 0 ;
5743 int res1 = 0 ;
5744 PyObject * obj0 = 0 ;
5745 PyObject * obj1 = 0 ;
5746 char * kwnames[] = {
5747 (char *) "self",(char *) "other", NULL
5748 };
5749
5750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5752 if (!SWIG_IsOK(res1)) {
5753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5754 }
5755 arg1 = reinterpret_cast< wxPoint * >(argp1);
5756 arg2 = obj1;
5757 {
5758 result = (bool)wxPoint___ne__(arg1,arg2);
5759 if (PyErr_Occurred()) SWIG_fail;
5760 }
5761 {
5762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5763 }
5764 return resultobj;
5765 fail:
5766 return NULL;
5767 }
5768
5769
5770 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5771 PyObject *resultobj = 0;
5772 wxPoint *arg1 = (wxPoint *) 0 ;
5773 wxPoint *arg2 = 0 ;
5774 wxPoint result;
5775 void *argp1 = 0 ;
5776 int res1 = 0 ;
5777 wxPoint temp2 ;
5778 PyObject * obj0 = 0 ;
5779 PyObject * obj1 = 0 ;
5780 char * kwnames[] = {
5781 (char *) "self",(char *) "pt", NULL
5782 };
5783
5784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5786 if (!SWIG_IsOK(res1)) {
5787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5788 }
5789 arg1 = reinterpret_cast< wxPoint * >(argp1);
5790 {
5791 arg2 = &temp2;
5792 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5793 }
5794 {
5795 PyThreadState* __tstate = wxPyBeginAllowThreads();
5796 result = (arg1)->operator +((wxPoint const &)*arg2);
5797 wxPyEndAllowThreads(__tstate);
5798 if (PyErr_Occurred()) SWIG_fail;
5799 }
5800 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5801 return resultobj;
5802 fail:
5803 return NULL;
5804 }
5805
5806
5807 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5808 PyObject *resultobj = 0;
5809 wxPoint *arg1 = (wxPoint *) 0 ;
5810 wxPoint *arg2 = 0 ;
5811 wxPoint result;
5812 void *argp1 = 0 ;
5813 int res1 = 0 ;
5814 wxPoint temp2 ;
5815 PyObject * obj0 = 0 ;
5816 PyObject * obj1 = 0 ;
5817 char * kwnames[] = {
5818 (char *) "self",(char *) "pt", NULL
5819 };
5820
5821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5823 if (!SWIG_IsOK(res1)) {
5824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5825 }
5826 arg1 = reinterpret_cast< wxPoint * >(argp1);
5827 {
5828 arg2 = &temp2;
5829 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5830 }
5831 {
5832 PyThreadState* __tstate = wxPyBeginAllowThreads();
5833 result = (arg1)->operator -((wxPoint const &)*arg2);
5834 wxPyEndAllowThreads(__tstate);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5838 return resultobj;
5839 fail:
5840 return NULL;
5841 }
5842
5843
5844 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5845 PyObject *resultobj = 0;
5846 wxPoint *arg1 = (wxPoint *) 0 ;
5847 wxPoint *arg2 = 0 ;
5848 wxPoint *result = 0 ;
5849 void *argp1 = 0 ;
5850 int res1 = 0 ;
5851 wxPoint temp2 ;
5852 PyObject * obj0 = 0 ;
5853 PyObject * obj1 = 0 ;
5854 char * kwnames[] = {
5855 (char *) "self",(char *) "pt", NULL
5856 };
5857
5858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5860 if (!SWIG_IsOK(res1)) {
5861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5862 }
5863 arg1 = reinterpret_cast< wxPoint * >(argp1);
5864 {
5865 arg2 = &temp2;
5866 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5867 }
5868 {
5869 PyThreadState* __tstate = wxPyBeginAllowThreads();
5870 {
5871 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5872 result = (wxPoint *) &_result_ref;
5873 }
5874 wxPyEndAllowThreads(__tstate);
5875 if (PyErr_Occurred()) SWIG_fail;
5876 }
5877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5878 return resultobj;
5879 fail:
5880 return NULL;
5881 }
5882
5883
5884 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5885 PyObject *resultobj = 0;
5886 wxPoint *arg1 = (wxPoint *) 0 ;
5887 wxPoint *arg2 = 0 ;
5888 wxPoint *result = 0 ;
5889 void *argp1 = 0 ;
5890 int res1 = 0 ;
5891 wxPoint temp2 ;
5892 PyObject * obj0 = 0 ;
5893 PyObject * obj1 = 0 ;
5894 char * kwnames[] = {
5895 (char *) "self",(char *) "pt", NULL
5896 };
5897
5898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5900 if (!SWIG_IsOK(res1)) {
5901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5902 }
5903 arg1 = reinterpret_cast< wxPoint * >(argp1);
5904 {
5905 arg2 = &temp2;
5906 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5907 }
5908 {
5909 PyThreadState* __tstate = wxPyBeginAllowThreads();
5910 {
5911 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5912 result = (wxPoint *) &_result_ref;
5913 }
5914 wxPyEndAllowThreads(__tstate);
5915 if (PyErr_Occurred()) SWIG_fail;
5916 }
5917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5918 return resultobj;
5919 fail:
5920 return NULL;
5921 }
5922
5923
5924 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5925 PyObject *resultobj = 0;
5926 wxPoint *arg1 = (wxPoint *) 0 ;
5927 long arg2 ;
5928 long arg3 ;
5929 void *argp1 = 0 ;
5930 int res1 = 0 ;
5931 long val2 ;
5932 int ecode2 = 0 ;
5933 long val3 ;
5934 int ecode3 = 0 ;
5935 PyObject * obj0 = 0 ;
5936 PyObject * obj1 = 0 ;
5937 PyObject * obj2 = 0 ;
5938 char * kwnames[] = {
5939 (char *) "self",(char *) "x",(char *) "y", NULL
5940 };
5941
5942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5944 if (!SWIG_IsOK(res1)) {
5945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5946 }
5947 arg1 = reinterpret_cast< wxPoint * >(argp1);
5948 ecode2 = SWIG_AsVal_long(obj1, &val2);
5949 if (!SWIG_IsOK(ecode2)) {
5950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5951 }
5952 arg2 = static_cast< long >(val2);
5953 ecode3 = SWIG_AsVal_long(obj2, &val3);
5954 if (!SWIG_IsOK(ecode3)) {
5955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5956 }
5957 arg3 = static_cast< long >(val3);
5958 {
5959 PyThreadState* __tstate = wxPyBeginAllowThreads();
5960 wxPoint_Set(arg1,arg2,arg3);
5961 wxPyEndAllowThreads(__tstate);
5962 if (PyErr_Occurred()) SWIG_fail;
5963 }
5964 resultobj = SWIG_Py_Void();
5965 return resultobj;
5966 fail:
5967 return NULL;
5968 }
5969
5970
5971 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5972 PyObject *resultobj = 0;
5973 wxPoint *arg1 = (wxPoint *) 0 ;
5974 PyObject *result = 0 ;
5975 void *argp1 = 0 ;
5976 int res1 = 0 ;
5977 PyObject *swig_obj[1] ;
5978
5979 if (!args) SWIG_fail;
5980 swig_obj[0] = args;
5981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5982 if (!SWIG_IsOK(res1)) {
5983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5984 }
5985 arg1 = reinterpret_cast< wxPoint * >(argp1);
5986 {
5987 PyThreadState* __tstate = wxPyBeginAllowThreads();
5988 result = (PyObject *)wxPoint_Get(arg1);
5989 wxPyEndAllowThreads(__tstate);
5990 if (PyErr_Occurred()) SWIG_fail;
5991 }
5992 resultobj = result;
5993 return resultobj;
5994 fail:
5995 return NULL;
5996 }
5997
5998
5999 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6000 PyObject *obj;
6001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6002 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6003 return SWIG_Py_Void();
6004 }
6005
6006 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6007 return SWIG_Python_InitShadowInstance(args);
6008 }
6009
6010 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6011 PyObject *resultobj = 0;
6012 int arg1 = (int) 0 ;
6013 int arg2 = (int) 0 ;
6014 int arg3 = (int) 0 ;
6015 int arg4 = (int) 0 ;
6016 wxRect *result = 0 ;
6017 int val1 ;
6018 int ecode1 = 0 ;
6019 int val2 ;
6020 int ecode2 = 0 ;
6021 int val3 ;
6022 int ecode3 = 0 ;
6023 int val4 ;
6024 int ecode4 = 0 ;
6025 PyObject * obj0 = 0 ;
6026 PyObject * obj1 = 0 ;
6027 PyObject * obj2 = 0 ;
6028 PyObject * obj3 = 0 ;
6029 char * kwnames[] = {
6030 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6031 };
6032
6033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6034 if (obj0) {
6035 ecode1 = SWIG_AsVal_int(obj0, &val1);
6036 if (!SWIG_IsOK(ecode1)) {
6037 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6038 }
6039 arg1 = static_cast< int >(val1);
6040 }
6041 if (obj1) {
6042 ecode2 = SWIG_AsVal_int(obj1, &val2);
6043 if (!SWIG_IsOK(ecode2)) {
6044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6045 }
6046 arg2 = static_cast< int >(val2);
6047 }
6048 if (obj2) {
6049 ecode3 = SWIG_AsVal_int(obj2, &val3);
6050 if (!SWIG_IsOK(ecode3)) {
6051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6052 }
6053 arg3 = static_cast< int >(val3);
6054 }
6055 if (obj3) {
6056 ecode4 = SWIG_AsVal_int(obj3, &val4);
6057 if (!SWIG_IsOK(ecode4)) {
6058 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6059 }
6060 arg4 = static_cast< int >(val4);
6061 }
6062 {
6063 PyThreadState* __tstate = wxPyBeginAllowThreads();
6064 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6065 wxPyEndAllowThreads(__tstate);
6066 if (PyErr_Occurred()) SWIG_fail;
6067 }
6068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6076 PyObject *resultobj = 0;
6077 wxPoint *arg1 = 0 ;
6078 wxPoint *arg2 = 0 ;
6079 wxRect *result = 0 ;
6080 wxPoint temp1 ;
6081 wxPoint temp2 ;
6082 PyObject * obj0 = 0 ;
6083 PyObject * obj1 = 0 ;
6084 char * kwnames[] = {
6085 (char *) "topLeft",(char *) "bottomRight", NULL
6086 };
6087
6088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6089 {
6090 arg1 = &temp1;
6091 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6092 }
6093 {
6094 arg2 = &temp2;
6095 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6096 }
6097 {
6098 PyThreadState* __tstate = wxPyBeginAllowThreads();
6099 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6100 wxPyEndAllowThreads(__tstate);
6101 if (PyErr_Occurred()) SWIG_fail;
6102 }
6103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6104 return resultobj;
6105 fail:
6106 return NULL;
6107 }
6108
6109
6110 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6111 PyObject *resultobj = 0;
6112 wxPoint *arg1 = 0 ;
6113 wxSize *arg2 = 0 ;
6114 wxRect *result = 0 ;
6115 wxPoint temp1 ;
6116 wxSize temp2 ;
6117 PyObject * obj0 = 0 ;
6118 PyObject * obj1 = 0 ;
6119 char * kwnames[] = {
6120 (char *) "pos",(char *) "size", NULL
6121 };
6122
6123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6124 {
6125 arg1 = &temp1;
6126 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6127 }
6128 {
6129 arg2 = &temp2;
6130 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6131 }
6132 {
6133 PyThreadState* __tstate = wxPyBeginAllowThreads();
6134 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6135 wxPyEndAllowThreads(__tstate);
6136 if (PyErr_Occurred()) SWIG_fail;
6137 }
6138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6139 return resultobj;
6140 fail:
6141 return NULL;
6142 }
6143
6144
6145 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6146 PyObject *resultobj = 0;
6147 wxSize *arg1 = 0 ;
6148 wxRect *result = 0 ;
6149 wxSize temp1 ;
6150 PyObject * obj0 = 0 ;
6151 char * kwnames[] = {
6152 (char *) "size", NULL
6153 };
6154
6155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6156 {
6157 arg1 = &temp1;
6158 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6159 }
6160 {
6161 PyThreadState* __tstate = wxPyBeginAllowThreads();
6162 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6163 wxPyEndAllowThreads(__tstate);
6164 if (PyErr_Occurred()) SWIG_fail;
6165 }
6166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6167 return resultobj;
6168 fail:
6169 return NULL;
6170 }
6171
6172
6173 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6174 PyObject *resultobj = 0;
6175 wxRect *arg1 = (wxRect *) 0 ;
6176 void *argp1 = 0 ;
6177 int res1 = 0 ;
6178 PyObject *swig_obj[1] ;
6179
6180 if (!args) SWIG_fail;
6181 swig_obj[0] = args;
6182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6183 if (!SWIG_IsOK(res1)) {
6184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6185 }
6186 arg1 = reinterpret_cast< wxRect * >(argp1);
6187 {
6188 PyThreadState* __tstate = wxPyBeginAllowThreads();
6189 delete arg1;
6190
6191 wxPyEndAllowThreads(__tstate);
6192 if (PyErr_Occurred()) SWIG_fail;
6193 }
6194 resultobj = SWIG_Py_Void();
6195 return resultobj;
6196 fail:
6197 return NULL;
6198 }
6199
6200
6201 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6202 PyObject *resultobj = 0;
6203 wxRect *arg1 = (wxRect *) 0 ;
6204 int result;
6205 void *argp1 = 0 ;
6206 int res1 = 0 ;
6207 PyObject *swig_obj[1] ;
6208
6209 if (!args) SWIG_fail;
6210 swig_obj[0] = args;
6211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6212 if (!SWIG_IsOK(res1)) {
6213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6214 }
6215 arg1 = reinterpret_cast< wxRect * >(argp1);
6216 {
6217 PyThreadState* __tstate = wxPyBeginAllowThreads();
6218 result = (int)((wxRect const *)arg1)->GetX();
6219 wxPyEndAllowThreads(__tstate);
6220 if (PyErr_Occurred()) SWIG_fail;
6221 }
6222 resultobj = SWIG_From_int(static_cast< int >(result));
6223 return resultobj;
6224 fail:
6225 return NULL;
6226 }
6227
6228
6229 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6230 PyObject *resultobj = 0;
6231 wxRect *arg1 = (wxRect *) 0 ;
6232 int arg2 ;
6233 void *argp1 = 0 ;
6234 int res1 = 0 ;
6235 int val2 ;
6236 int ecode2 = 0 ;
6237 PyObject * obj0 = 0 ;
6238 PyObject * obj1 = 0 ;
6239 char * kwnames[] = {
6240 (char *) "self",(char *) "x", NULL
6241 };
6242
6243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6245 if (!SWIG_IsOK(res1)) {
6246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6247 }
6248 arg1 = reinterpret_cast< wxRect * >(argp1);
6249 ecode2 = SWIG_AsVal_int(obj1, &val2);
6250 if (!SWIG_IsOK(ecode2)) {
6251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6252 }
6253 arg2 = static_cast< int >(val2);
6254 {
6255 PyThreadState* __tstate = wxPyBeginAllowThreads();
6256 (arg1)->SetX(arg2);
6257 wxPyEndAllowThreads(__tstate);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 resultobj = SWIG_Py_Void();
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6268 PyObject *resultobj = 0;
6269 wxRect *arg1 = (wxRect *) 0 ;
6270 int result;
6271 void *argp1 = 0 ;
6272 int res1 = 0 ;
6273 PyObject *swig_obj[1] ;
6274
6275 if (!args) SWIG_fail;
6276 swig_obj[0] = args;
6277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6278 if (!SWIG_IsOK(res1)) {
6279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6280 }
6281 arg1 = reinterpret_cast< wxRect * >(argp1);
6282 {
6283 PyThreadState* __tstate = wxPyBeginAllowThreads();
6284 result = (int)(arg1)->GetY();
6285 wxPyEndAllowThreads(__tstate);
6286 if (PyErr_Occurred()) SWIG_fail;
6287 }
6288 resultobj = SWIG_From_int(static_cast< int >(result));
6289 return resultobj;
6290 fail:
6291 return NULL;
6292 }
6293
6294
6295 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6296 PyObject *resultobj = 0;
6297 wxRect *arg1 = (wxRect *) 0 ;
6298 int arg2 ;
6299 void *argp1 = 0 ;
6300 int res1 = 0 ;
6301 int val2 ;
6302 int ecode2 = 0 ;
6303 PyObject * obj0 = 0 ;
6304 PyObject * obj1 = 0 ;
6305 char * kwnames[] = {
6306 (char *) "self",(char *) "y", NULL
6307 };
6308
6309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6311 if (!SWIG_IsOK(res1)) {
6312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6313 }
6314 arg1 = reinterpret_cast< wxRect * >(argp1);
6315 ecode2 = SWIG_AsVal_int(obj1, &val2);
6316 if (!SWIG_IsOK(ecode2)) {
6317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6318 }
6319 arg2 = static_cast< int >(val2);
6320 {
6321 PyThreadState* __tstate = wxPyBeginAllowThreads();
6322 (arg1)->SetY(arg2);
6323 wxPyEndAllowThreads(__tstate);
6324 if (PyErr_Occurred()) SWIG_fail;
6325 }
6326 resultobj = SWIG_Py_Void();
6327 return resultobj;
6328 fail:
6329 return NULL;
6330 }
6331
6332
6333 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6334 PyObject *resultobj = 0;
6335 wxRect *arg1 = (wxRect *) 0 ;
6336 int result;
6337 void *argp1 = 0 ;
6338 int res1 = 0 ;
6339 PyObject *swig_obj[1] ;
6340
6341 if (!args) SWIG_fail;
6342 swig_obj[0] = args;
6343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6344 if (!SWIG_IsOK(res1)) {
6345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6346 }
6347 arg1 = reinterpret_cast< wxRect * >(argp1);
6348 {
6349 PyThreadState* __tstate = wxPyBeginAllowThreads();
6350 result = (int)((wxRect const *)arg1)->GetWidth();
6351 wxPyEndAllowThreads(__tstate);
6352 if (PyErr_Occurred()) SWIG_fail;
6353 }
6354 resultobj = SWIG_From_int(static_cast< int >(result));
6355 return resultobj;
6356 fail:
6357 return NULL;
6358 }
6359
6360
6361 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6362 PyObject *resultobj = 0;
6363 wxRect *arg1 = (wxRect *) 0 ;
6364 int arg2 ;
6365 void *argp1 = 0 ;
6366 int res1 = 0 ;
6367 int val2 ;
6368 int ecode2 = 0 ;
6369 PyObject * obj0 = 0 ;
6370 PyObject * obj1 = 0 ;
6371 char * kwnames[] = {
6372 (char *) "self",(char *) "w", NULL
6373 };
6374
6375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6377 if (!SWIG_IsOK(res1)) {
6378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6379 }
6380 arg1 = reinterpret_cast< wxRect * >(argp1);
6381 ecode2 = SWIG_AsVal_int(obj1, &val2);
6382 if (!SWIG_IsOK(ecode2)) {
6383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6384 }
6385 arg2 = static_cast< int >(val2);
6386 {
6387 PyThreadState* __tstate = wxPyBeginAllowThreads();
6388 (arg1)->SetWidth(arg2);
6389 wxPyEndAllowThreads(__tstate);
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 resultobj = SWIG_Py_Void();
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6400 PyObject *resultobj = 0;
6401 wxRect *arg1 = (wxRect *) 0 ;
6402 int result;
6403 void *argp1 = 0 ;
6404 int res1 = 0 ;
6405 PyObject *swig_obj[1] ;
6406
6407 if (!args) SWIG_fail;
6408 swig_obj[0] = args;
6409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6410 if (!SWIG_IsOK(res1)) {
6411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6412 }
6413 arg1 = reinterpret_cast< wxRect * >(argp1);
6414 {
6415 PyThreadState* __tstate = wxPyBeginAllowThreads();
6416 result = (int)((wxRect const *)arg1)->GetHeight();
6417 wxPyEndAllowThreads(__tstate);
6418 if (PyErr_Occurred()) SWIG_fail;
6419 }
6420 resultobj = SWIG_From_int(static_cast< int >(result));
6421 return resultobj;
6422 fail:
6423 return NULL;
6424 }
6425
6426
6427 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6428 PyObject *resultobj = 0;
6429 wxRect *arg1 = (wxRect *) 0 ;
6430 int arg2 ;
6431 void *argp1 = 0 ;
6432 int res1 = 0 ;
6433 int val2 ;
6434 int ecode2 = 0 ;
6435 PyObject * obj0 = 0 ;
6436 PyObject * obj1 = 0 ;
6437 char * kwnames[] = {
6438 (char *) "self",(char *) "h", NULL
6439 };
6440
6441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6443 if (!SWIG_IsOK(res1)) {
6444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6445 }
6446 arg1 = reinterpret_cast< wxRect * >(argp1);
6447 ecode2 = SWIG_AsVal_int(obj1, &val2);
6448 if (!SWIG_IsOK(ecode2)) {
6449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6450 }
6451 arg2 = static_cast< int >(val2);
6452 {
6453 PyThreadState* __tstate = wxPyBeginAllowThreads();
6454 (arg1)->SetHeight(arg2);
6455 wxPyEndAllowThreads(__tstate);
6456 if (PyErr_Occurred()) SWIG_fail;
6457 }
6458 resultobj = SWIG_Py_Void();
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6466 PyObject *resultobj = 0;
6467 wxRect *arg1 = (wxRect *) 0 ;
6468 wxPoint result;
6469 void *argp1 = 0 ;
6470 int res1 = 0 ;
6471 PyObject *swig_obj[1] ;
6472
6473 if (!args) SWIG_fail;
6474 swig_obj[0] = args;
6475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6476 if (!SWIG_IsOK(res1)) {
6477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6478 }
6479 arg1 = reinterpret_cast< wxRect * >(argp1);
6480 {
6481 PyThreadState* __tstate = wxPyBeginAllowThreads();
6482 result = ((wxRect const *)arg1)->GetPosition();
6483 wxPyEndAllowThreads(__tstate);
6484 if (PyErr_Occurred()) SWIG_fail;
6485 }
6486 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6487 return resultobj;
6488 fail:
6489 return NULL;
6490 }
6491
6492
6493 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6494 PyObject *resultobj = 0;
6495 wxRect *arg1 = (wxRect *) 0 ;
6496 wxPoint *arg2 = 0 ;
6497 void *argp1 = 0 ;
6498 int res1 = 0 ;
6499 wxPoint temp2 ;
6500 PyObject * obj0 = 0 ;
6501 PyObject * obj1 = 0 ;
6502 char * kwnames[] = {
6503 (char *) "self",(char *) "p", NULL
6504 };
6505
6506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6508 if (!SWIG_IsOK(res1)) {
6509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6510 }
6511 arg1 = reinterpret_cast< wxRect * >(argp1);
6512 {
6513 arg2 = &temp2;
6514 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6515 }
6516 {
6517 PyThreadState* __tstate = wxPyBeginAllowThreads();
6518 (arg1)->SetPosition((wxPoint const &)*arg2);
6519 wxPyEndAllowThreads(__tstate);
6520 if (PyErr_Occurred()) SWIG_fail;
6521 }
6522 resultobj = SWIG_Py_Void();
6523 return resultobj;
6524 fail:
6525 return NULL;
6526 }
6527
6528
6529 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6530 PyObject *resultobj = 0;
6531 wxRect *arg1 = (wxRect *) 0 ;
6532 wxSize 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_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6542 }
6543 arg1 = reinterpret_cast< wxRect * >(argp1);
6544 {
6545 PyThreadState* __tstate = wxPyBeginAllowThreads();
6546 result = ((wxRect const *)arg1)->GetSize();
6547 wxPyEndAllowThreads(__tstate);
6548 if (PyErr_Occurred()) SWIG_fail;
6549 }
6550 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6551 return resultobj;
6552 fail:
6553 return NULL;
6554 }
6555
6556
6557 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6558 PyObject *resultobj = 0;
6559 wxRect *arg1 = (wxRect *) 0 ;
6560 wxSize *arg2 = 0 ;
6561 void *argp1 = 0 ;
6562 int res1 = 0 ;
6563 wxSize temp2 ;
6564 PyObject * obj0 = 0 ;
6565 PyObject * obj1 = 0 ;
6566 char * kwnames[] = {
6567 (char *) "self",(char *) "s", NULL
6568 };
6569
6570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",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_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6574 }
6575 arg1 = reinterpret_cast< wxRect * >(argp1);
6576 {
6577 arg2 = &temp2;
6578 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6579 }
6580 {
6581 PyThreadState* __tstate = wxPyBeginAllowThreads();
6582 (arg1)->SetSize((wxSize 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_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6594 PyObject *resultobj = 0;
6595 wxRect *arg1 = (wxRect *) 0 ;
6596 bool 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_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6606 }
6607 arg1 = reinterpret_cast< wxRect * >(argp1);
6608 {
6609 PyThreadState* __tstate = wxPyBeginAllowThreads();
6610 result = (bool)((wxRect const *)arg1)->IsEmpty();
6611 wxPyEndAllowThreads(__tstate);
6612 if (PyErr_Occurred()) SWIG_fail;
6613 }
6614 {
6615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6616 }
6617 return resultobj;
6618 fail:
6619 return NULL;
6620 }
6621
6622
6623 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6624 PyObject *resultobj = 0;
6625 wxRect *arg1 = (wxRect *) 0 ;
6626 wxPoint result;
6627 void *argp1 = 0 ;
6628 int res1 = 0 ;
6629 PyObject *swig_obj[1] ;
6630
6631 if (!args) SWIG_fail;
6632 swig_obj[0] = args;
6633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6634 if (!SWIG_IsOK(res1)) {
6635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6636 }
6637 arg1 = reinterpret_cast< wxRect * >(argp1);
6638 {
6639 PyThreadState* __tstate = wxPyBeginAllowThreads();
6640 result = ((wxRect const *)arg1)->GetTopLeft();
6641 wxPyEndAllowThreads(__tstate);
6642 if (PyErr_Occurred()) SWIG_fail;
6643 }
6644 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6645 return resultobj;
6646 fail:
6647 return NULL;
6648 }
6649
6650
6651 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6652 PyObject *resultobj = 0;
6653 wxRect *arg1 = (wxRect *) 0 ;
6654 wxPoint *arg2 = 0 ;
6655 void *argp1 = 0 ;
6656 int res1 = 0 ;
6657 wxPoint temp2 ;
6658 PyObject * obj0 = 0 ;
6659 PyObject * obj1 = 0 ;
6660 char * kwnames[] = {
6661 (char *) "self",(char *) "p", NULL
6662 };
6663
6664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6666 if (!SWIG_IsOK(res1)) {
6667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6668 }
6669 arg1 = reinterpret_cast< wxRect * >(argp1);
6670 {
6671 arg2 = &temp2;
6672 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6673 }
6674 {
6675 PyThreadState* __tstate = wxPyBeginAllowThreads();
6676 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6677 wxPyEndAllowThreads(__tstate);
6678 if (PyErr_Occurred()) SWIG_fail;
6679 }
6680 resultobj = SWIG_Py_Void();
6681 return resultobj;
6682 fail:
6683 return NULL;
6684 }
6685
6686
6687 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6688 PyObject *resultobj = 0;
6689 wxRect *arg1 = (wxRect *) 0 ;
6690 wxPoint result;
6691 void *argp1 = 0 ;
6692 int res1 = 0 ;
6693 PyObject *swig_obj[1] ;
6694
6695 if (!args) SWIG_fail;
6696 swig_obj[0] = args;
6697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6698 if (!SWIG_IsOK(res1)) {
6699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6700 }
6701 arg1 = reinterpret_cast< wxRect * >(argp1);
6702 {
6703 PyThreadState* __tstate = wxPyBeginAllowThreads();
6704 result = ((wxRect const *)arg1)->GetBottomRight();
6705 wxPyEndAllowThreads(__tstate);
6706 if (PyErr_Occurred()) SWIG_fail;
6707 }
6708 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6709 return resultobj;
6710 fail:
6711 return NULL;
6712 }
6713
6714
6715 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6716 PyObject *resultobj = 0;
6717 wxRect *arg1 = (wxRect *) 0 ;
6718 wxPoint *arg2 = 0 ;
6719 void *argp1 = 0 ;
6720 int res1 = 0 ;
6721 wxPoint temp2 ;
6722 PyObject * obj0 = 0 ;
6723 PyObject * obj1 = 0 ;
6724 char * kwnames[] = {
6725 (char *) "self",(char *) "p", NULL
6726 };
6727
6728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6730 if (!SWIG_IsOK(res1)) {
6731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6732 }
6733 arg1 = reinterpret_cast< wxRect * >(argp1);
6734 {
6735 arg2 = &temp2;
6736 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6737 }
6738 {
6739 PyThreadState* __tstate = wxPyBeginAllowThreads();
6740 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6741 wxPyEndAllowThreads(__tstate);
6742 if (PyErr_Occurred()) SWIG_fail;
6743 }
6744 resultobj = SWIG_Py_Void();
6745 return resultobj;
6746 fail:
6747 return NULL;
6748 }
6749
6750
6751 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6752 PyObject *resultobj = 0;
6753 wxRect *arg1 = (wxRect *) 0 ;
6754 int result;
6755 void *argp1 = 0 ;
6756 int res1 = 0 ;
6757 PyObject *swig_obj[1] ;
6758
6759 if (!args) SWIG_fail;
6760 swig_obj[0] = args;
6761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6762 if (!SWIG_IsOK(res1)) {
6763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6764 }
6765 arg1 = reinterpret_cast< wxRect * >(argp1);
6766 {
6767 PyThreadState* __tstate = wxPyBeginAllowThreads();
6768 result = (int)((wxRect const *)arg1)->GetLeft();
6769 wxPyEndAllowThreads(__tstate);
6770 if (PyErr_Occurred()) SWIG_fail;
6771 }
6772 resultobj = SWIG_From_int(static_cast< int >(result));
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6780 PyObject *resultobj = 0;
6781 wxRect *arg1 = (wxRect *) 0 ;
6782 int result;
6783 void *argp1 = 0 ;
6784 int res1 = 0 ;
6785 PyObject *swig_obj[1] ;
6786
6787 if (!args) SWIG_fail;
6788 swig_obj[0] = args;
6789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6790 if (!SWIG_IsOK(res1)) {
6791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6792 }
6793 arg1 = reinterpret_cast< wxRect * >(argp1);
6794 {
6795 PyThreadState* __tstate = wxPyBeginAllowThreads();
6796 result = (int)((wxRect const *)arg1)->GetTop();
6797 wxPyEndAllowThreads(__tstate);
6798 if (PyErr_Occurred()) SWIG_fail;
6799 }
6800 resultobj = SWIG_From_int(static_cast< int >(result));
6801 return resultobj;
6802 fail:
6803 return NULL;
6804 }
6805
6806
6807 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6808 PyObject *resultobj = 0;
6809 wxRect *arg1 = (wxRect *) 0 ;
6810 int result;
6811 void *argp1 = 0 ;
6812 int res1 = 0 ;
6813 PyObject *swig_obj[1] ;
6814
6815 if (!args) SWIG_fail;
6816 swig_obj[0] = args;
6817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6818 if (!SWIG_IsOK(res1)) {
6819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6820 }
6821 arg1 = reinterpret_cast< wxRect * >(argp1);
6822 {
6823 PyThreadState* __tstate = wxPyBeginAllowThreads();
6824 result = (int)((wxRect const *)arg1)->GetBottom();
6825 wxPyEndAllowThreads(__tstate);
6826 if (PyErr_Occurred()) SWIG_fail;
6827 }
6828 resultobj = SWIG_From_int(static_cast< int >(result));
6829 return resultobj;
6830 fail:
6831 return NULL;
6832 }
6833
6834
6835 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6836 PyObject *resultobj = 0;
6837 wxRect *arg1 = (wxRect *) 0 ;
6838 int result;
6839 void *argp1 = 0 ;
6840 int res1 = 0 ;
6841 PyObject *swig_obj[1] ;
6842
6843 if (!args) SWIG_fail;
6844 swig_obj[0] = args;
6845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6846 if (!SWIG_IsOK(res1)) {
6847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6848 }
6849 arg1 = reinterpret_cast< wxRect * >(argp1);
6850 {
6851 PyThreadState* __tstate = wxPyBeginAllowThreads();
6852 result = (int)((wxRect const *)arg1)->GetRight();
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 resultobj = SWIG_From_int(static_cast< int >(result));
6857 return resultobj;
6858 fail:
6859 return NULL;
6860 }
6861
6862
6863 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6864 PyObject *resultobj = 0;
6865 wxRect *arg1 = (wxRect *) 0 ;
6866 int arg2 ;
6867 void *argp1 = 0 ;
6868 int res1 = 0 ;
6869 int val2 ;
6870 int ecode2 = 0 ;
6871 PyObject * obj0 = 0 ;
6872 PyObject * obj1 = 0 ;
6873 char * kwnames[] = {
6874 (char *) "self",(char *) "left", NULL
6875 };
6876
6877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6879 if (!SWIG_IsOK(res1)) {
6880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6881 }
6882 arg1 = reinterpret_cast< wxRect * >(argp1);
6883 ecode2 = SWIG_AsVal_int(obj1, &val2);
6884 if (!SWIG_IsOK(ecode2)) {
6885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6886 }
6887 arg2 = static_cast< int >(val2);
6888 {
6889 PyThreadState* __tstate = wxPyBeginAllowThreads();
6890 (arg1)->SetLeft(arg2);
6891 wxPyEndAllowThreads(__tstate);
6892 if (PyErr_Occurred()) SWIG_fail;
6893 }
6894 resultobj = SWIG_Py_Void();
6895 return resultobj;
6896 fail:
6897 return NULL;
6898 }
6899
6900
6901 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6902 PyObject *resultobj = 0;
6903 wxRect *arg1 = (wxRect *) 0 ;
6904 int arg2 ;
6905 void *argp1 = 0 ;
6906 int res1 = 0 ;
6907 int val2 ;
6908 int ecode2 = 0 ;
6909 PyObject * obj0 = 0 ;
6910 PyObject * obj1 = 0 ;
6911 char * kwnames[] = {
6912 (char *) "self",(char *) "right", NULL
6913 };
6914
6915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6917 if (!SWIG_IsOK(res1)) {
6918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6919 }
6920 arg1 = reinterpret_cast< wxRect * >(argp1);
6921 ecode2 = SWIG_AsVal_int(obj1, &val2);
6922 if (!SWIG_IsOK(ecode2)) {
6923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6924 }
6925 arg2 = static_cast< int >(val2);
6926 {
6927 PyThreadState* __tstate = wxPyBeginAllowThreads();
6928 (arg1)->SetRight(arg2);
6929 wxPyEndAllowThreads(__tstate);
6930 if (PyErr_Occurred()) SWIG_fail;
6931 }
6932 resultobj = SWIG_Py_Void();
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6940 PyObject *resultobj = 0;
6941 wxRect *arg1 = (wxRect *) 0 ;
6942 int arg2 ;
6943 void *argp1 = 0 ;
6944 int res1 = 0 ;
6945 int val2 ;
6946 int ecode2 = 0 ;
6947 PyObject * obj0 = 0 ;
6948 PyObject * obj1 = 0 ;
6949 char * kwnames[] = {
6950 (char *) "self",(char *) "top", NULL
6951 };
6952
6953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6955 if (!SWIG_IsOK(res1)) {
6956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6957 }
6958 arg1 = reinterpret_cast< wxRect * >(argp1);
6959 ecode2 = SWIG_AsVal_int(obj1, &val2);
6960 if (!SWIG_IsOK(ecode2)) {
6961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6962 }
6963 arg2 = static_cast< int >(val2);
6964 {
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 (arg1)->SetTop(arg2);
6967 wxPyEndAllowThreads(__tstate);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_Py_Void();
6971 return resultobj;
6972 fail:
6973 return NULL;
6974 }
6975
6976
6977 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6978 PyObject *resultobj = 0;
6979 wxRect *arg1 = (wxRect *) 0 ;
6980 int arg2 ;
6981 void *argp1 = 0 ;
6982 int res1 = 0 ;
6983 int val2 ;
6984 int ecode2 = 0 ;
6985 PyObject * obj0 = 0 ;
6986 PyObject * obj1 = 0 ;
6987 char * kwnames[] = {
6988 (char *) "self",(char *) "bottom", NULL
6989 };
6990
6991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6993 if (!SWIG_IsOK(res1)) {
6994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', 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_SetBottom" "', expected argument " "2"" of type '" "int""'");
7000 }
7001 arg2 = static_cast< int >(val2);
7002 {
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 (arg1)->SetBottom(arg2);
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 resultobj = SWIG_Py_Void();
7009 return resultobj;
7010 fail:
7011 return NULL;
7012 }
7013
7014
7015 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7016 PyObject *resultobj = 0;
7017 wxRect *arg1 = (wxRect *) 0 ;
7018 int arg2 ;
7019 int arg3 ;
7020 wxRect *result = 0 ;
7021 void *argp1 = 0 ;
7022 int res1 = 0 ;
7023 int val2 ;
7024 int ecode2 = 0 ;
7025 int val3 ;
7026 int ecode3 = 0 ;
7027 PyObject * obj0 = 0 ;
7028 PyObject * obj1 = 0 ;
7029 PyObject * obj2 = 0 ;
7030 char * kwnames[] = {
7031 (char *) "self",(char *) "dx",(char *) "dy", NULL
7032 };
7033
7034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7036 if (!SWIG_IsOK(res1)) {
7037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7038 }
7039 arg1 = reinterpret_cast< wxRect * >(argp1);
7040 ecode2 = SWIG_AsVal_int(obj1, &val2);
7041 if (!SWIG_IsOK(ecode2)) {
7042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7043 }
7044 arg2 = static_cast< int >(val2);
7045 ecode3 = SWIG_AsVal_int(obj2, &val3);
7046 if (!SWIG_IsOK(ecode3)) {
7047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7048 }
7049 arg3 = static_cast< int >(val3);
7050 {
7051 PyThreadState* __tstate = wxPyBeginAllowThreads();
7052 {
7053 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7054 result = (wxRect *) &_result_ref;
7055 }
7056 wxPyEndAllowThreads(__tstate);
7057 if (PyErr_Occurred()) SWIG_fail;
7058 }
7059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7060 return resultobj;
7061 fail:
7062 return NULL;
7063 }
7064
7065
7066 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7067 PyObject *resultobj = 0;
7068 wxRect *arg1 = (wxRect *) 0 ;
7069 int arg2 ;
7070 int arg3 ;
7071 wxRect *result = 0 ;
7072 void *argp1 = 0 ;
7073 int res1 = 0 ;
7074 int val2 ;
7075 int ecode2 = 0 ;
7076 int val3 ;
7077 int ecode3 = 0 ;
7078 PyObject * obj0 = 0 ;
7079 PyObject * obj1 = 0 ;
7080 PyObject * obj2 = 0 ;
7081 char * kwnames[] = {
7082 (char *) "self",(char *) "dx",(char *) "dy", NULL
7083 };
7084
7085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7087 if (!SWIG_IsOK(res1)) {
7088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7089 }
7090 arg1 = reinterpret_cast< wxRect * >(argp1);
7091 ecode2 = SWIG_AsVal_int(obj1, &val2);
7092 if (!SWIG_IsOK(ecode2)) {
7093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7094 }
7095 arg2 = static_cast< int >(val2);
7096 ecode3 = SWIG_AsVal_int(obj2, &val3);
7097 if (!SWIG_IsOK(ecode3)) {
7098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7099 }
7100 arg3 = static_cast< int >(val3);
7101 {
7102 PyThreadState* __tstate = wxPyBeginAllowThreads();
7103 {
7104 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7105 result = (wxRect *) &_result_ref;
7106 }
7107 wxPyEndAllowThreads(__tstate);
7108 if (PyErr_Occurred()) SWIG_fail;
7109 }
7110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7111 return resultobj;
7112 fail:
7113 return NULL;
7114 }
7115
7116
7117 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7118 PyObject *resultobj = 0;
7119 wxRect *arg1 = (wxRect *) 0 ;
7120 int arg2 ;
7121 int arg3 ;
7122 void *argp1 = 0 ;
7123 int res1 = 0 ;
7124 int val2 ;
7125 int ecode2 = 0 ;
7126 int val3 ;
7127 int ecode3 = 0 ;
7128 PyObject * obj0 = 0 ;
7129 PyObject * obj1 = 0 ;
7130 PyObject * obj2 = 0 ;
7131 char * kwnames[] = {
7132 (char *) "self",(char *) "dx",(char *) "dy", NULL
7133 };
7134
7135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7137 if (!SWIG_IsOK(res1)) {
7138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7139 }
7140 arg1 = reinterpret_cast< wxRect * >(argp1);
7141 ecode2 = SWIG_AsVal_int(obj1, &val2);
7142 if (!SWIG_IsOK(ecode2)) {
7143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7144 }
7145 arg2 = static_cast< int >(val2);
7146 ecode3 = SWIG_AsVal_int(obj2, &val3);
7147 if (!SWIG_IsOK(ecode3)) {
7148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7149 }
7150 arg3 = static_cast< int >(val3);
7151 {
7152 PyThreadState* __tstate = wxPyBeginAllowThreads();
7153 (arg1)->Offset(arg2,arg3);
7154 wxPyEndAllowThreads(__tstate);
7155 if (PyErr_Occurred()) SWIG_fail;
7156 }
7157 resultobj = SWIG_Py_Void();
7158 return resultobj;
7159 fail:
7160 return NULL;
7161 }
7162
7163
7164 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7165 PyObject *resultobj = 0;
7166 wxRect *arg1 = (wxRect *) 0 ;
7167 wxPoint *arg2 = 0 ;
7168 void *argp1 = 0 ;
7169 int res1 = 0 ;
7170 wxPoint temp2 ;
7171 PyObject * obj0 = 0 ;
7172 PyObject * obj1 = 0 ;
7173 char * kwnames[] = {
7174 (char *) "self",(char *) "pt", NULL
7175 };
7176
7177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7179 if (!SWIG_IsOK(res1)) {
7180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7181 }
7182 arg1 = reinterpret_cast< wxRect * >(argp1);
7183 {
7184 arg2 = &temp2;
7185 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7186 }
7187 {
7188 PyThreadState* __tstate = wxPyBeginAllowThreads();
7189 (arg1)->Offset((wxPoint const &)*arg2);
7190 wxPyEndAllowThreads(__tstate);
7191 if (PyErr_Occurred()) SWIG_fail;
7192 }
7193 resultobj = SWIG_Py_Void();
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7201 PyObject *resultobj = 0;
7202 wxRect *arg1 = (wxRect *) 0 ;
7203 wxRect *arg2 = 0 ;
7204 wxRect result;
7205 void *argp1 = 0 ;
7206 int res1 = 0 ;
7207 wxRect temp2 ;
7208 PyObject * obj0 = 0 ;
7209 PyObject * obj1 = 0 ;
7210 char * kwnames[] = {
7211 (char *) "self",(char *) "rect", NULL
7212 };
7213
7214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7216 if (!SWIG_IsOK(res1)) {
7217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7218 }
7219 arg1 = reinterpret_cast< wxRect * >(argp1);
7220 {
7221 arg2 = &temp2;
7222 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7223 }
7224 {
7225 PyThreadState* __tstate = wxPyBeginAllowThreads();
7226 result = (arg1)->Intersect((wxRect const &)*arg2);
7227 wxPyEndAllowThreads(__tstate);
7228 if (PyErr_Occurred()) SWIG_fail;
7229 }
7230 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7231 return resultobj;
7232 fail:
7233 return NULL;
7234 }
7235
7236
7237 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7238 PyObject *resultobj = 0;
7239 wxRect *arg1 = (wxRect *) 0 ;
7240 wxRect *arg2 = 0 ;
7241 wxRect result;
7242 void *argp1 = 0 ;
7243 int res1 = 0 ;
7244 wxRect temp2 ;
7245 PyObject * obj0 = 0 ;
7246 PyObject * obj1 = 0 ;
7247 char * kwnames[] = {
7248 (char *) "self",(char *) "rect", NULL
7249 };
7250
7251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7253 if (!SWIG_IsOK(res1)) {
7254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7255 }
7256 arg1 = reinterpret_cast< wxRect * >(argp1);
7257 {
7258 arg2 = &temp2;
7259 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7260 }
7261 {
7262 PyThreadState* __tstate = wxPyBeginAllowThreads();
7263 result = (arg1)->Union((wxRect const &)*arg2);
7264 wxPyEndAllowThreads(__tstate);
7265 if (PyErr_Occurred()) SWIG_fail;
7266 }
7267 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7268 return resultobj;
7269 fail:
7270 return NULL;
7271 }
7272
7273
7274 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7275 PyObject *resultobj = 0;
7276 wxRect *arg1 = (wxRect *) 0 ;
7277 wxRect *arg2 = 0 ;
7278 wxRect result;
7279 void *argp1 = 0 ;
7280 int res1 = 0 ;
7281 wxRect temp2 ;
7282 PyObject * obj0 = 0 ;
7283 PyObject * obj1 = 0 ;
7284 char * kwnames[] = {
7285 (char *) "self",(char *) "rect", NULL
7286 };
7287
7288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7290 if (!SWIG_IsOK(res1)) {
7291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7292 }
7293 arg1 = reinterpret_cast< wxRect * >(argp1);
7294 {
7295 arg2 = &temp2;
7296 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7297 }
7298 {
7299 PyThreadState* __tstate = wxPyBeginAllowThreads();
7300 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7301 wxPyEndAllowThreads(__tstate);
7302 if (PyErr_Occurred()) SWIG_fail;
7303 }
7304 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7305 return resultobj;
7306 fail:
7307 return NULL;
7308 }
7309
7310
7311 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7312 PyObject *resultobj = 0;
7313 wxRect *arg1 = (wxRect *) 0 ;
7314 wxRect *arg2 = 0 ;
7315 wxRect *result = 0 ;
7316 void *argp1 = 0 ;
7317 int res1 = 0 ;
7318 wxRect temp2 ;
7319 PyObject * obj0 = 0 ;
7320 PyObject * obj1 = 0 ;
7321 char * kwnames[] = {
7322 (char *) "self",(char *) "rect", NULL
7323 };
7324
7325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7327 if (!SWIG_IsOK(res1)) {
7328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7329 }
7330 arg1 = reinterpret_cast< wxRect * >(argp1);
7331 {
7332 arg2 = &temp2;
7333 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7334 }
7335 {
7336 PyThreadState* __tstate = wxPyBeginAllowThreads();
7337 {
7338 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7339 result = (wxRect *) &_result_ref;
7340 }
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj = 0;
7353 wxRect *arg1 = (wxRect *) 0 ;
7354 PyObject *arg2 = (PyObject *) 0 ;
7355 bool result;
7356 void *argp1 = 0 ;
7357 int res1 = 0 ;
7358 PyObject * obj0 = 0 ;
7359 PyObject * obj1 = 0 ;
7360 char * kwnames[] = {
7361 (char *) "self",(char *) "other", NULL
7362 };
7363
7364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7366 if (!SWIG_IsOK(res1)) {
7367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7368 }
7369 arg1 = reinterpret_cast< wxRect * >(argp1);
7370 arg2 = obj1;
7371 {
7372 result = (bool)wxRect___eq__(arg1,arg2);
7373 if (PyErr_Occurred()) SWIG_fail;
7374 }
7375 {
7376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7377 }
7378 return resultobj;
7379 fail:
7380 return NULL;
7381 }
7382
7383
7384 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7385 PyObject *resultobj = 0;
7386 wxRect *arg1 = (wxRect *) 0 ;
7387 PyObject *arg2 = (PyObject *) 0 ;
7388 bool result;
7389 void *argp1 = 0 ;
7390 int res1 = 0 ;
7391 PyObject * obj0 = 0 ;
7392 PyObject * obj1 = 0 ;
7393 char * kwnames[] = {
7394 (char *) "self",(char *) "other", NULL
7395 };
7396
7397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7399 if (!SWIG_IsOK(res1)) {
7400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7401 }
7402 arg1 = reinterpret_cast< wxRect * >(argp1);
7403 arg2 = obj1;
7404 {
7405 result = (bool)wxRect___ne__(arg1,arg2);
7406 if (PyErr_Occurred()) SWIG_fail;
7407 }
7408 {
7409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7410 }
7411 return resultobj;
7412 fail:
7413 return NULL;
7414 }
7415
7416
7417 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7418 PyObject *resultobj = 0;
7419 wxRect *arg1 = (wxRect *) 0 ;
7420 int arg2 ;
7421 int arg3 ;
7422 bool result;
7423 void *argp1 = 0 ;
7424 int res1 = 0 ;
7425 int val2 ;
7426 int ecode2 = 0 ;
7427 int val3 ;
7428 int ecode3 = 0 ;
7429 PyObject * obj0 = 0 ;
7430 PyObject * obj1 = 0 ;
7431 PyObject * obj2 = 0 ;
7432 char * kwnames[] = {
7433 (char *) "self",(char *) "x",(char *) "y", NULL
7434 };
7435
7436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7438 if (!SWIG_IsOK(res1)) {
7439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7440 }
7441 arg1 = reinterpret_cast< wxRect * >(argp1);
7442 ecode2 = SWIG_AsVal_int(obj1, &val2);
7443 if (!SWIG_IsOK(ecode2)) {
7444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7445 }
7446 arg2 = static_cast< int >(val2);
7447 ecode3 = SWIG_AsVal_int(obj2, &val3);
7448 if (!SWIG_IsOK(ecode3)) {
7449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7450 }
7451 arg3 = static_cast< int >(val3);
7452 {
7453 PyThreadState* __tstate = wxPyBeginAllowThreads();
7454 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7455 wxPyEndAllowThreads(__tstate);
7456 if (PyErr_Occurred()) SWIG_fail;
7457 }
7458 {
7459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7460 }
7461 return resultobj;
7462 fail:
7463 return NULL;
7464 }
7465
7466
7467 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7468 PyObject *resultobj = 0;
7469 wxRect *arg1 = (wxRect *) 0 ;
7470 wxPoint *arg2 = 0 ;
7471 bool result;
7472 void *argp1 = 0 ;
7473 int res1 = 0 ;
7474 wxPoint temp2 ;
7475 PyObject * obj0 = 0 ;
7476 PyObject * obj1 = 0 ;
7477 char * kwnames[] = {
7478 (char *) "self",(char *) "pt", NULL
7479 };
7480
7481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) 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_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7485 }
7486 arg1 = reinterpret_cast< wxRect * >(argp1);
7487 {
7488 arg2 = &temp2;
7489 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7490 }
7491 {
7492 PyThreadState* __tstate = wxPyBeginAllowThreads();
7493 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7494 wxPyEndAllowThreads(__tstate);
7495 if (PyErr_Occurred()) SWIG_fail;
7496 }
7497 {
7498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7499 }
7500 return resultobj;
7501 fail:
7502 return NULL;
7503 }
7504
7505
7506 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7507 PyObject *resultobj = 0;
7508 wxRect *arg1 = (wxRect *) 0 ;
7509 wxRect *arg2 = 0 ;
7510 bool result;
7511 void *argp1 = 0 ;
7512 int res1 = 0 ;
7513 wxRect temp2 ;
7514 PyObject * obj0 = 0 ;
7515 PyObject * obj1 = 0 ;
7516 char * kwnames[] = {
7517 (char *) "self",(char *) "rect", NULL
7518 };
7519
7520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7522 if (!SWIG_IsOK(res1)) {
7523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7524 }
7525 arg1 = reinterpret_cast< wxRect * >(argp1);
7526 {
7527 arg2 = &temp2;
7528 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7529 }
7530 {
7531 PyThreadState* __tstate = wxPyBeginAllowThreads();
7532 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7533 wxPyEndAllowThreads(__tstate);
7534 if (PyErr_Occurred()) SWIG_fail;
7535 }
7536 {
7537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7538 }
7539 return resultobj;
7540 fail:
7541 return NULL;
7542 }
7543
7544
7545 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7546 PyObject *resultobj = 0;
7547 wxRect *arg1 = (wxRect *) 0 ;
7548 wxRect *arg2 = 0 ;
7549 int arg3 = (int) wxBOTH ;
7550 wxRect result;
7551 void *argp1 = 0 ;
7552 int res1 = 0 ;
7553 wxRect temp2 ;
7554 int val3 ;
7555 int ecode3 = 0 ;
7556 PyObject * obj0 = 0 ;
7557 PyObject * obj1 = 0 ;
7558 PyObject * obj2 = 0 ;
7559 char * kwnames[] = {
7560 (char *) "self",(char *) "r",(char *) "dir", NULL
7561 };
7562
7563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7565 if (!SWIG_IsOK(res1)) {
7566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7567 }
7568 arg1 = reinterpret_cast< wxRect * >(argp1);
7569 {
7570 arg2 = &temp2;
7571 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7572 }
7573 if (obj2) {
7574 ecode3 = SWIG_AsVal_int(obj2, &val3);
7575 if (!SWIG_IsOK(ecode3)) {
7576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7577 }
7578 arg3 = static_cast< int >(val3);
7579 }
7580 {
7581 PyThreadState* __tstate = wxPyBeginAllowThreads();
7582 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7583 wxPyEndAllowThreads(__tstate);
7584 if (PyErr_Occurred()) SWIG_fail;
7585 }
7586 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7587 return resultobj;
7588 fail:
7589 return NULL;
7590 }
7591
7592
7593 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7594 PyObject *resultobj = 0;
7595 wxRect *arg1 = (wxRect *) 0 ;
7596 int arg2 ;
7597 void *argp1 = 0 ;
7598 int res1 = 0 ;
7599 int val2 ;
7600 int ecode2 = 0 ;
7601 PyObject *swig_obj[2] ;
7602
7603 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
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_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7607 }
7608 arg1 = reinterpret_cast< wxRect * >(argp1);
7609 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7610 if (!SWIG_IsOK(ecode2)) {
7611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7612 }
7613 arg2 = static_cast< int >(val2);
7614 if (arg1) (arg1)->x = arg2;
7615
7616 resultobj = SWIG_Py_Void();
7617 return resultobj;
7618 fail:
7619 return NULL;
7620 }
7621
7622
7623 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7624 PyObject *resultobj = 0;
7625 wxRect *arg1 = (wxRect *) 0 ;
7626 int result;
7627 void *argp1 = 0 ;
7628 int res1 = 0 ;
7629 PyObject *swig_obj[1] ;
7630
7631 if (!args) SWIG_fail;
7632 swig_obj[0] = args;
7633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7634 if (!SWIG_IsOK(res1)) {
7635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7636 }
7637 arg1 = reinterpret_cast< wxRect * >(argp1);
7638 result = (int) ((arg1)->x);
7639 resultobj = SWIG_From_int(static_cast< int >(result));
7640 return resultobj;
7641 fail:
7642 return NULL;
7643 }
7644
7645
7646 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7647 PyObject *resultobj = 0;
7648 wxRect *arg1 = (wxRect *) 0 ;
7649 int arg2 ;
7650 void *argp1 = 0 ;
7651 int res1 = 0 ;
7652 int val2 ;
7653 int ecode2 = 0 ;
7654 PyObject *swig_obj[2] ;
7655
7656 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
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_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7660 }
7661 arg1 = reinterpret_cast< wxRect * >(argp1);
7662 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7663 if (!SWIG_IsOK(ecode2)) {
7664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7665 }
7666 arg2 = static_cast< int >(val2);
7667 if (arg1) (arg1)->y = arg2;
7668
7669 resultobj = SWIG_Py_Void();
7670 return resultobj;
7671 fail:
7672 return NULL;
7673 }
7674
7675
7676 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7677 PyObject *resultobj = 0;
7678 wxRect *arg1 = (wxRect *) 0 ;
7679 int result;
7680 void *argp1 = 0 ;
7681 int res1 = 0 ;
7682 PyObject *swig_obj[1] ;
7683
7684 if (!args) SWIG_fail;
7685 swig_obj[0] = args;
7686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7687 if (!SWIG_IsOK(res1)) {
7688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7689 }
7690 arg1 = reinterpret_cast< wxRect * >(argp1);
7691 result = (int) ((arg1)->y);
7692 resultobj = SWIG_From_int(static_cast< int >(result));
7693 return resultobj;
7694 fail:
7695 return NULL;
7696 }
7697
7698
7699 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7700 PyObject *resultobj = 0;
7701 wxRect *arg1 = (wxRect *) 0 ;
7702 int arg2 ;
7703 void *argp1 = 0 ;
7704 int res1 = 0 ;
7705 int val2 ;
7706 int ecode2 = 0 ;
7707 PyObject *swig_obj[2] ;
7708
7709 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
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_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7713 }
7714 arg1 = reinterpret_cast< wxRect * >(argp1);
7715 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7716 if (!SWIG_IsOK(ecode2)) {
7717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7718 }
7719 arg2 = static_cast< int >(val2);
7720 if (arg1) (arg1)->width = arg2;
7721
7722 resultobj = SWIG_Py_Void();
7723 return resultobj;
7724 fail:
7725 return NULL;
7726 }
7727
7728
7729 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7730 PyObject *resultobj = 0;
7731 wxRect *arg1 = (wxRect *) 0 ;
7732 int result;
7733 void *argp1 = 0 ;
7734 int res1 = 0 ;
7735 PyObject *swig_obj[1] ;
7736
7737 if (!args) SWIG_fail;
7738 swig_obj[0] = args;
7739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7740 if (!SWIG_IsOK(res1)) {
7741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7742 }
7743 arg1 = reinterpret_cast< wxRect * >(argp1);
7744 result = (int) ((arg1)->width);
7745 resultobj = SWIG_From_int(static_cast< int >(result));
7746 return resultobj;
7747 fail:
7748 return NULL;
7749 }
7750
7751
7752 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7753 PyObject *resultobj = 0;
7754 wxRect *arg1 = (wxRect *) 0 ;
7755 int arg2 ;
7756 void *argp1 = 0 ;
7757 int res1 = 0 ;
7758 int val2 ;
7759 int ecode2 = 0 ;
7760 PyObject *swig_obj[2] ;
7761
7762 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7764 if (!SWIG_IsOK(res1)) {
7765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7766 }
7767 arg1 = reinterpret_cast< wxRect * >(argp1);
7768 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7769 if (!SWIG_IsOK(ecode2)) {
7770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7771 }
7772 arg2 = static_cast< int >(val2);
7773 if (arg1) (arg1)->height = arg2;
7774
7775 resultobj = SWIG_Py_Void();
7776 return resultobj;
7777 fail:
7778 return NULL;
7779 }
7780
7781
7782 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7783 PyObject *resultobj = 0;
7784 wxRect *arg1 = (wxRect *) 0 ;
7785 int result;
7786 void *argp1 = 0 ;
7787 int res1 = 0 ;
7788 PyObject *swig_obj[1] ;
7789
7790 if (!args) SWIG_fail;
7791 swig_obj[0] = args;
7792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7793 if (!SWIG_IsOK(res1)) {
7794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7795 }
7796 arg1 = reinterpret_cast< wxRect * >(argp1);
7797 result = (int) ((arg1)->height);
7798 resultobj = SWIG_From_int(static_cast< int >(result));
7799 return resultobj;
7800 fail:
7801 return NULL;
7802 }
7803
7804
7805 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7806 PyObject *resultobj = 0;
7807 wxRect *arg1 = (wxRect *) 0 ;
7808 int arg2 = (int) 0 ;
7809 int arg3 = (int) 0 ;
7810 int arg4 = (int) 0 ;
7811 int arg5 = (int) 0 ;
7812 void *argp1 = 0 ;
7813 int res1 = 0 ;
7814 int val2 ;
7815 int ecode2 = 0 ;
7816 int val3 ;
7817 int ecode3 = 0 ;
7818 int val4 ;
7819 int ecode4 = 0 ;
7820 int val5 ;
7821 int ecode5 = 0 ;
7822 PyObject * obj0 = 0 ;
7823 PyObject * obj1 = 0 ;
7824 PyObject * obj2 = 0 ;
7825 PyObject * obj3 = 0 ;
7826 PyObject * obj4 = 0 ;
7827 char * kwnames[] = {
7828 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7829 };
7830
7831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7833 if (!SWIG_IsOK(res1)) {
7834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7835 }
7836 arg1 = reinterpret_cast< wxRect * >(argp1);
7837 if (obj1) {
7838 ecode2 = SWIG_AsVal_int(obj1, &val2);
7839 if (!SWIG_IsOK(ecode2)) {
7840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7841 }
7842 arg2 = static_cast< int >(val2);
7843 }
7844 if (obj2) {
7845 ecode3 = SWIG_AsVal_int(obj2, &val3);
7846 if (!SWIG_IsOK(ecode3)) {
7847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7848 }
7849 arg3 = static_cast< int >(val3);
7850 }
7851 if (obj3) {
7852 ecode4 = SWIG_AsVal_int(obj3, &val4);
7853 if (!SWIG_IsOK(ecode4)) {
7854 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7855 }
7856 arg4 = static_cast< int >(val4);
7857 }
7858 if (obj4) {
7859 ecode5 = SWIG_AsVal_int(obj4, &val5);
7860 if (!SWIG_IsOK(ecode5)) {
7861 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7862 }
7863 arg5 = static_cast< int >(val5);
7864 }
7865 {
7866 PyThreadState* __tstate = wxPyBeginAllowThreads();
7867 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7868 wxPyEndAllowThreads(__tstate);
7869 if (PyErr_Occurred()) SWIG_fail;
7870 }
7871 resultobj = SWIG_Py_Void();
7872 return resultobj;
7873 fail:
7874 return NULL;
7875 }
7876
7877
7878 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7879 PyObject *resultobj = 0;
7880 wxRect *arg1 = (wxRect *) 0 ;
7881 PyObject *result = 0 ;
7882 void *argp1 = 0 ;
7883 int res1 = 0 ;
7884 PyObject *swig_obj[1] ;
7885
7886 if (!args) SWIG_fail;
7887 swig_obj[0] = args;
7888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7889 if (!SWIG_IsOK(res1)) {
7890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7891 }
7892 arg1 = reinterpret_cast< wxRect * >(argp1);
7893 {
7894 PyThreadState* __tstate = wxPyBeginAllowThreads();
7895 result = (PyObject *)wxRect_Get(arg1);
7896 wxPyEndAllowThreads(__tstate);
7897 if (PyErr_Occurred()) SWIG_fail;
7898 }
7899 resultobj = result;
7900 return resultobj;
7901 fail:
7902 return NULL;
7903 }
7904
7905
7906 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7907 PyObject *obj;
7908 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7909 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7910 return SWIG_Py_Void();
7911 }
7912
7913 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7914 return SWIG_Python_InitShadowInstance(args);
7915 }
7916
7917 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7918 PyObject *resultobj = 0;
7919 wxRect *arg1 = (wxRect *) 0 ;
7920 wxRect *arg2 = (wxRect *) 0 ;
7921 PyObject *result = 0 ;
7922 void *argp1 = 0 ;
7923 int res1 = 0 ;
7924 void *argp2 = 0 ;
7925 int res2 = 0 ;
7926 PyObject * obj0 = 0 ;
7927 PyObject * obj1 = 0 ;
7928 char * kwnames[] = {
7929 (char *) "r1",(char *) "r2", NULL
7930 };
7931
7932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7934 if (!SWIG_IsOK(res1)) {
7935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7936 }
7937 arg1 = reinterpret_cast< wxRect * >(argp1);
7938 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7939 if (!SWIG_IsOK(res2)) {
7940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7941 }
7942 arg2 = reinterpret_cast< wxRect * >(argp2);
7943 {
7944 if (!wxPyCheckForApp()) SWIG_fail;
7945 PyThreadState* __tstate = wxPyBeginAllowThreads();
7946 result = (PyObject *)wxIntersectRect(arg1,arg2);
7947 wxPyEndAllowThreads(__tstate);
7948 if (PyErr_Occurred()) SWIG_fail;
7949 }
7950 resultobj = result;
7951 return resultobj;
7952 fail:
7953 return NULL;
7954 }
7955
7956
7957 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7958 PyObject *resultobj = 0;
7959 double arg1 = (double) 0.0 ;
7960 double arg2 = (double) 0.0 ;
7961 wxPoint2D *result = 0 ;
7962 double val1 ;
7963 int ecode1 = 0 ;
7964 double val2 ;
7965 int ecode2 = 0 ;
7966 PyObject * obj0 = 0 ;
7967 PyObject * obj1 = 0 ;
7968 char * kwnames[] = {
7969 (char *) "x",(char *) "y", NULL
7970 };
7971
7972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7973 if (obj0) {
7974 ecode1 = SWIG_AsVal_double(obj0, &val1);
7975 if (!SWIG_IsOK(ecode1)) {
7976 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7977 }
7978 arg1 = static_cast< double >(val1);
7979 }
7980 if (obj1) {
7981 ecode2 = SWIG_AsVal_double(obj1, &val2);
7982 if (!SWIG_IsOK(ecode2)) {
7983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7984 }
7985 arg2 = static_cast< double >(val2);
7986 }
7987 {
7988 PyThreadState* __tstate = wxPyBeginAllowThreads();
7989 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7990 wxPyEndAllowThreads(__tstate);
7991 if (PyErr_Occurred()) SWIG_fail;
7992 }
7993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7994 return resultobj;
7995 fail:
7996 return NULL;
7997 }
7998
7999
8000 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8001 PyObject *resultobj = 0;
8002 wxPoint2D *arg1 = 0 ;
8003 wxPoint2D *result = 0 ;
8004 wxPoint2D temp1 ;
8005 PyObject * obj0 = 0 ;
8006 char * kwnames[] = {
8007 (char *) "pt", NULL
8008 };
8009
8010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8011 {
8012 arg1 = &temp1;
8013 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8014 }
8015 {
8016 PyThreadState* __tstate = wxPyBeginAllowThreads();
8017 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8018 wxPyEndAllowThreads(__tstate);
8019 if (PyErr_Occurred()) SWIG_fail;
8020 }
8021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8022 return resultobj;
8023 fail:
8024 return NULL;
8025 }
8026
8027
8028 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8029 PyObject *resultobj = 0;
8030 wxPoint *arg1 = 0 ;
8031 wxPoint2D *result = 0 ;
8032 wxPoint temp1 ;
8033 PyObject * obj0 = 0 ;
8034 char * kwnames[] = {
8035 (char *) "pt", NULL
8036 };
8037
8038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8039 {
8040 arg1 = &temp1;
8041 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8042 }
8043 {
8044 PyThreadState* __tstate = wxPyBeginAllowThreads();
8045 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8046 wxPyEndAllowThreads(__tstate);
8047 if (PyErr_Occurred()) SWIG_fail;
8048 }
8049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8050 return resultobj;
8051 fail:
8052 return NULL;
8053 }
8054
8055
8056 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8057 PyObject *resultobj = 0;
8058 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8059 int *arg2 = (int *) 0 ;
8060 int *arg3 = (int *) 0 ;
8061 void *argp1 = 0 ;
8062 int res1 = 0 ;
8063 int temp2 ;
8064 int res2 = SWIG_TMPOBJ ;
8065 int temp3 ;
8066 int res3 = SWIG_TMPOBJ ;
8067 PyObject *swig_obj[1] ;
8068
8069 arg2 = &temp2;
8070 arg3 = &temp3;
8071 if (!args) SWIG_fail;
8072 swig_obj[0] = args;
8073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8074 if (!SWIG_IsOK(res1)) {
8075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8076 }
8077 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8078 {
8079 PyThreadState* __tstate = wxPyBeginAllowThreads();
8080 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8081 wxPyEndAllowThreads(__tstate);
8082 if (PyErr_Occurred()) SWIG_fail;
8083 }
8084 resultobj = SWIG_Py_Void();
8085 if (SWIG_IsTmpObj(res2)) {
8086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8087 } else {
8088 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8090 }
8091 if (SWIG_IsTmpObj(res3)) {
8092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8093 } else {
8094 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8096 }
8097 return resultobj;
8098 fail:
8099 return NULL;
8100 }
8101
8102
8103 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8104 PyObject *resultobj = 0;
8105 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8106 int *arg2 = (int *) 0 ;
8107 int *arg3 = (int *) 0 ;
8108 void *argp1 = 0 ;
8109 int res1 = 0 ;
8110 int temp2 ;
8111 int res2 = SWIG_TMPOBJ ;
8112 int temp3 ;
8113 int res3 = SWIG_TMPOBJ ;
8114 PyObject *swig_obj[1] ;
8115
8116 arg2 = &temp2;
8117 arg3 = &temp3;
8118 if (!args) SWIG_fail;
8119 swig_obj[0] = args;
8120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8121 if (!SWIG_IsOK(res1)) {
8122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8123 }
8124 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8125 {
8126 PyThreadState* __tstate = wxPyBeginAllowThreads();
8127 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8128 wxPyEndAllowThreads(__tstate);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 resultobj = SWIG_Py_Void();
8132 if (SWIG_IsTmpObj(res2)) {
8133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8134 } else {
8135 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8137 }
8138 if (SWIG_IsTmpObj(res3)) {
8139 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8140 } else {
8141 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8143 }
8144 return resultobj;
8145 fail:
8146 return NULL;
8147 }
8148
8149
8150 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8151 PyObject *resultobj = 0;
8152 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8153 double result;
8154 void *argp1 = 0 ;
8155 int res1 = 0 ;
8156 PyObject *swig_obj[1] ;
8157
8158 if (!args) SWIG_fail;
8159 swig_obj[0] = args;
8160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8161 if (!SWIG_IsOK(res1)) {
8162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8163 }
8164 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8165 {
8166 PyThreadState* __tstate = wxPyBeginAllowThreads();
8167 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8168 wxPyEndAllowThreads(__tstate);
8169 if (PyErr_Occurred()) SWIG_fail;
8170 }
8171 resultobj = SWIG_From_double(static_cast< double >(result));
8172 return resultobj;
8173 fail:
8174 return NULL;
8175 }
8176
8177
8178 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8179 PyObject *resultobj = 0;
8180 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8181 double result;
8182 void *argp1 = 0 ;
8183 int res1 = 0 ;
8184 PyObject *swig_obj[1] ;
8185
8186 if (!args) SWIG_fail;
8187 swig_obj[0] = args;
8188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8189 if (!SWIG_IsOK(res1)) {
8190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8191 }
8192 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8193 {
8194 PyThreadState* __tstate = wxPyBeginAllowThreads();
8195 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8196 wxPyEndAllowThreads(__tstate);
8197 if (PyErr_Occurred()) SWIG_fail;
8198 }
8199 resultobj = SWIG_From_double(static_cast< double >(result));
8200 return resultobj;
8201 fail:
8202 return NULL;
8203 }
8204
8205
8206 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8207 PyObject *resultobj = 0;
8208 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8209 double arg2 ;
8210 void *argp1 = 0 ;
8211 int res1 = 0 ;
8212 double val2 ;
8213 int ecode2 = 0 ;
8214 PyObject * obj0 = 0 ;
8215 PyObject * obj1 = 0 ;
8216 char * kwnames[] = {
8217 (char *) "self",(char *) "length", NULL
8218 };
8219
8220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8222 if (!SWIG_IsOK(res1)) {
8223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8224 }
8225 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8226 ecode2 = SWIG_AsVal_double(obj1, &val2);
8227 if (!SWIG_IsOK(ecode2)) {
8228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8229 }
8230 arg2 = static_cast< double >(val2);
8231 {
8232 PyThreadState* __tstate = wxPyBeginAllowThreads();
8233 (arg1)->SetVectorLength(arg2);
8234 wxPyEndAllowThreads(__tstate);
8235 if (PyErr_Occurred()) SWIG_fail;
8236 }
8237 resultobj = SWIG_Py_Void();
8238 return resultobj;
8239 fail:
8240 return NULL;
8241 }
8242
8243
8244 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8245 PyObject *resultobj = 0;
8246 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8247 double arg2 ;
8248 void *argp1 = 0 ;
8249 int res1 = 0 ;
8250 double val2 ;
8251 int ecode2 = 0 ;
8252 PyObject * obj0 = 0 ;
8253 PyObject * obj1 = 0 ;
8254 char * kwnames[] = {
8255 (char *) "self",(char *) "degrees", NULL
8256 };
8257
8258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8260 if (!SWIG_IsOK(res1)) {
8261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8262 }
8263 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8264 ecode2 = SWIG_AsVal_double(obj1, &val2);
8265 if (!SWIG_IsOK(ecode2)) {
8266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8267 }
8268 arg2 = static_cast< double >(val2);
8269 {
8270 PyThreadState* __tstate = wxPyBeginAllowThreads();
8271 (arg1)->SetVectorAngle(arg2);
8272 wxPyEndAllowThreads(__tstate);
8273 if (PyErr_Occurred()) SWIG_fail;
8274 }
8275 resultobj = SWIG_Py_Void();
8276 return resultobj;
8277 fail:
8278 return NULL;
8279 }
8280
8281
8282 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8283 PyObject *resultobj = 0;
8284 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8285 wxPoint2D *arg2 = 0 ;
8286 double result;
8287 void *argp1 = 0 ;
8288 int res1 = 0 ;
8289 wxPoint2D temp2 ;
8290 PyObject * obj0 = 0 ;
8291 PyObject * obj1 = 0 ;
8292 char * kwnames[] = {
8293 (char *) "self",(char *) "pt", NULL
8294 };
8295
8296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8298 if (!SWIG_IsOK(res1)) {
8299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8300 }
8301 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8302 {
8303 arg2 = &temp2;
8304 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8305 }
8306 {
8307 PyThreadState* __tstate = wxPyBeginAllowThreads();
8308 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8309 wxPyEndAllowThreads(__tstate);
8310 if (PyErr_Occurred()) SWIG_fail;
8311 }
8312 resultobj = SWIG_From_double(static_cast< double >(result));
8313 return resultobj;
8314 fail:
8315 return NULL;
8316 }
8317
8318
8319 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8320 PyObject *resultobj = 0;
8321 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8322 wxPoint2D *arg2 = 0 ;
8323 double result;
8324 void *argp1 = 0 ;
8325 int res1 = 0 ;
8326 wxPoint2D temp2 ;
8327 PyObject * obj0 = 0 ;
8328 PyObject * obj1 = 0 ;
8329 char * kwnames[] = {
8330 (char *) "self",(char *) "pt", NULL
8331 };
8332
8333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8335 if (!SWIG_IsOK(res1)) {
8336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8337 }
8338 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8339 {
8340 arg2 = &temp2;
8341 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8342 }
8343 {
8344 PyThreadState* __tstate = wxPyBeginAllowThreads();
8345 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8346 wxPyEndAllowThreads(__tstate);
8347 if (PyErr_Occurred()) SWIG_fail;
8348 }
8349 resultobj = SWIG_From_double(static_cast< double >(result));
8350 return resultobj;
8351 fail:
8352 return NULL;
8353 }
8354
8355
8356 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8357 PyObject *resultobj = 0;
8358 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8359 wxPoint2D *arg2 = 0 ;
8360 double result;
8361 void *argp1 = 0 ;
8362 int res1 = 0 ;
8363 wxPoint2D temp2 ;
8364 PyObject * obj0 = 0 ;
8365 PyObject * obj1 = 0 ;
8366 char * kwnames[] = {
8367 (char *) "self",(char *) "vec", NULL
8368 };
8369
8370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8372 if (!SWIG_IsOK(res1)) {
8373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8374 }
8375 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8376 {
8377 arg2 = &temp2;
8378 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8379 }
8380 {
8381 PyThreadState* __tstate = wxPyBeginAllowThreads();
8382 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8383 wxPyEndAllowThreads(__tstate);
8384 if (PyErr_Occurred()) SWIG_fail;
8385 }
8386 resultobj = SWIG_From_double(static_cast< double >(result));
8387 return resultobj;
8388 fail:
8389 return NULL;
8390 }
8391
8392
8393 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8394 PyObject *resultobj = 0;
8395 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8396 wxPoint2D *arg2 = 0 ;
8397 double result;
8398 void *argp1 = 0 ;
8399 int res1 = 0 ;
8400 wxPoint2D temp2 ;
8401 PyObject * obj0 = 0 ;
8402 PyObject * obj1 = 0 ;
8403 char * kwnames[] = {
8404 (char *) "self",(char *) "vec", NULL
8405 };
8406
8407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8409 if (!SWIG_IsOK(res1)) {
8410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8411 }
8412 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8413 {
8414 arg2 = &temp2;
8415 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8416 }
8417 {
8418 PyThreadState* __tstate = wxPyBeginAllowThreads();
8419 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8420 wxPyEndAllowThreads(__tstate);
8421 if (PyErr_Occurred()) SWIG_fail;
8422 }
8423 resultobj = SWIG_From_double(static_cast< double >(result));
8424 return resultobj;
8425 fail:
8426 return NULL;
8427 }
8428
8429
8430 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8431 PyObject *resultobj = 0;
8432 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8433 wxPoint2D result;
8434 void *argp1 = 0 ;
8435 int res1 = 0 ;
8436 PyObject *swig_obj[1] ;
8437
8438 if (!args) SWIG_fail;
8439 swig_obj[0] = args;
8440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8441 if (!SWIG_IsOK(res1)) {
8442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8443 }
8444 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8445 {
8446 PyThreadState* __tstate = wxPyBeginAllowThreads();
8447 result = (arg1)->operator -();
8448 wxPyEndAllowThreads(__tstate);
8449 if (PyErr_Occurred()) SWIG_fail;
8450 }
8451 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8459 PyObject *resultobj = 0;
8460 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8461 wxPoint2D *arg2 = 0 ;
8462 wxPoint2D *result = 0 ;
8463 void *argp1 = 0 ;
8464 int res1 = 0 ;
8465 wxPoint2D temp2 ;
8466 PyObject * obj0 = 0 ;
8467 PyObject * obj1 = 0 ;
8468 char * kwnames[] = {
8469 (char *) "self",(char *) "pt", NULL
8470 };
8471
8472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8474 if (!SWIG_IsOK(res1)) {
8475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8476 }
8477 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8478 {
8479 arg2 = &temp2;
8480 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8481 }
8482 {
8483 PyThreadState* __tstate = wxPyBeginAllowThreads();
8484 {
8485 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8486 result = (wxPoint2D *) &_result_ref;
8487 }
8488 wxPyEndAllowThreads(__tstate);
8489 if (PyErr_Occurred()) SWIG_fail;
8490 }
8491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8492 return resultobj;
8493 fail:
8494 return NULL;
8495 }
8496
8497
8498 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8499 PyObject *resultobj = 0;
8500 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8501 wxPoint2D *arg2 = 0 ;
8502 wxPoint2D *result = 0 ;
8503 void *argp1 = 0 ;
8504 int res1 = 0 ;
8505 wxPoint2D temp2 ;
8506 PyObject * obj0 = 0 ;
8507 PyObject * obj1 = 0 ;
8508 char * kwnames[] = {
8509 (char *) "self",(char *) "pt", NULL
8510 };
8511
8512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8514 if (!SWIG_IsOK(res1)) {
8515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8516 }
8517 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8518 {
8519 arg2 = &temp2;
8520 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8521 }
8522 {
8523 PyThreadState* __tstate = wxPyBeginAllowThreads();
8524 {
8525 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8526 result = (wxPoint2D *) &_result_ref;
8527 }
8528 wxPyEndAllowThreads(__tstate);
8529 if (PyErr_Occurred()) SWIG_fail;
8530 }
8531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8532 return resultobj;
8533 fail:
8534 return NULL;
8535 }
8536
8537
8538 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8539 PyObject *resultobj = 0;
8540 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8541 wxPoint2D *arg2 = 0 ;
8542 wxPoint2D *result = 0 ;
8543 void *argp1 = 0 ;
8544 int res1 = 0 ;
8545 wxPoint2D temp2 ;
8546 PyObject * obj0 = 0 ;
8547 PyObject * obj1 = 0 ;
8548 char * kwnames[] = {
8549 (char *) "self",(char *) "pt", NULL
8550 };
8551
8552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8554 if (!SWIG_IsOK(res1)) {
8555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8556 }
8557 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8558 {
8559 arg2 = &temp2;
8560 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8561 }
8562 {
8563 PyThreadState* __tstate = wxPyBeginAllowThreads();
8564 {
8565 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8566 result = (wxPoint2D *) &_result_ref;
8567 }
8568 wxPyEndAllowThreads(__tstate);
8569 if (PyErr_Occurred()) SWIG_fail;
8570 }
8571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8572 return resultobj;
8573 fail:
8574 return NULL;
8575 }
8576
8577
8578 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8579 PyObject *resultobj = 0;
8580 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8581 wxPoint2D *arg2 = 0 ;
8582 wxPoint2D *result = 0 ;
8583 void *argp1 = 0 ;
8584 int res1 = 0 ;
8585 wxPoint2D temp2 ;
8586 PyObject * obj0 = 0 ;
8587 PyObject * obj1 = 0 ;
8588 char * kwnames[] = {
8589 (char *) "self",(char *) "pt", NULL
8590 };
8591
8592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8594 if (!SWIG_IsOK(res1)) {
8595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8596 }
8597 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8598 {
8599 arg2 = &temp2;
8600 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8601 }
8602 {
8603 PyThreadState* __tstate = wxPyBeginAllowThreads();
8604 {
8605 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8606 result = (wxPoint2D *) &_result_ref;
8607 }
8608 wxPyEndAllowThreads(__tstate);
8609 if (PyErr_Occurred()) SWIG_fail;
8610 }
8611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8612 return resultobj;
8613 fail:
8614 return NULL;
8615 }
8616
8617
8618 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8619 PyObject *resultobj = 0;
8620 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8621 PyObject *arg2 = (PyObject *) 0 ;
8622 bool result;
8623 void *argp1 = 0 ;
8624 int res1 = 0 ;
8625 PyObject * obj0 = 0 ;
8626 PyObject * obj1 = 0 ;
8627 char * kwnames[] = {
8628 (char *) "self",(char *) "other", NULL
8629 };
8630
8631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8633 if (!SWIG_IsOK(res1)) {
8634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8635 }
8636 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8637 arg2 = obj1;
8638 {
8639 result = (bool)wxPoint2D___eq__(arg1,arg2);
8640 if (PyErr_Occurred()) SWIG_fail;
8641 }
8642 {
8643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8644 }
8645 return resultobj;
8646 fail:
8647 return NULL;
8648 }
8649
8650
8651 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8652 PyObject *resultobj = 0;
8653 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8654 PyObject *arg2 = (PyObject *) 0 ;
8655 bool result;
8656 void *argp1 = 0 ;
8657 int res1 = 0 ;
8658 PyObject * obj0 = 0 ;
8659 PyObject * obj1 = 0 ;
8660 char * kwnames[] = {
8661 (char *) "self",(char *) "other", NULL
8662 };
8663
8664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8666 if (!SWIG_IsOK(res1)) {
8667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8668 }
8669 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8670 arg2 = obj1;
8671 {
8672 result = (bool)wxPoint2D___ne__(arg1,arg2);
8673 if (PyErr_Occurred()) SWIG_fail;
8674 }
8675 {
8676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8677 }
8678 return resultobj;
8679 fail:
8680 return NULL;
8681 }
8682
8683
8684 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8685 PyObject *resultobj = 0;
8686 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8687 double arg2 ;
8688 void *argp1 = 0 ;
8689 int res1 = 0 ;
8690 double val2 ;
8691 int ecode2 = 0 ;
8692 PyObject *swig_obj[2] ;
8693
8694 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8696 if (!SWIG_IsOK(res1)) {
8697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8698 }
8699 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8700 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8701 if (!SWIG_IsOK(ecode2)) {
8702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8703 }
8704 arg2 = static_cast< double >(val2);
8705 if (arg1) (arg1)->m_x = arg2;
8706
8707 resultobj = SWIG_Py_Void();
8708 return resultobj;
8709 fail:
8710 return NULL;
8711 }
8712
8713
8714 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8715 PyObject *resultobj = 0;
8716 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8717 double result;
8718 void *argp1 = 0 ;
8719 int res1 = 0 ;
8720 PyObject *swig_obj[1] ;
8721
8722 if (!args) SWIG_fail;
8723 swig_obj[0] = args;
8724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8725 if (!SWIG_IsOK(res1)) {
8726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8727 }
8728 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8729 result = (double) ((arg1)->m_x);
8730 resultobj = SWIG_From_double(static_cast< double >(result));
8731 return resultobj;
8732 fail:
8733 return NULL;
8734 }
8735
8736
8737 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8738 PyObject *resultobj = 0;
8739 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8740 double arg2 ;
8741 void *argp1 = 0 ;
8742 int res1 = 0 ;
8743 double val2 ;
8744 int ecode2 = 0 ;
8745 PyObject *swig_obj[2] ;
8746
8747 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8749 if (!SWIG_IsOK(res1)) {
8750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8751 }
8752 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8753 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8754 if (!SWIG_IsOK(ecode2)) {
8755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8756 }
8757 arg2 = static_cast< double >(val2);
8758 if (arg1) (arg1)->m_y = arg2;
8759
8760 resultobj = SWIG_Py_Void();
8761 return resultobj;
8762 fail:
8763 return NULL;
8764 }
8765
8766
8767 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8768 PyObject *resultobj = 0;
8769 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8770 double result;
8771 void *argp1 = 0 ;
8772 int res1 = 0 ;
8773 PyObject *swig_obj[1] ;
8774
8775 if (!args) SWIG_fail;
8776 swig_obj[0] = args;
8777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8778 if (!SWIG_IsOK(res1)) {
8779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8780 }
8781 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8782 result = (double) ((arg1)->m_y);
8783 resultobj = SWIG_From_double(static_cast< double >(result));
8784 return resultobj;
8785 fail:
8786 return NULL;
8787 }
8788
8789
8790 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8791 PyObject *resultobj = 0;
8792 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8793 double arg2 = (double) 0 ;
8794 double arg3 = (double) 0 ;
8795 void *argp1 = 0 ;
8796 int res1 = 0 ;
8797 double val2 ;
8798 int ecode2 = 0 ;
8799 double val3 ;
8800 int ecode3 = 0 ;
8801 PyObject * obj0 = 0 ;
8802 PyObject * obj1 = 0 ;
8803 PyObject * obj2 = 0 ;
8804 char * kwnames[] = {
8805 (char *) "self",(char *) "x",(char *) "y", NULL
8806 };
8807
8808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8810 if (!SWIG_IsOK(res1)) {
8811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8812 }
8813 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8814 if (obj1) {
8815 ecode2 = SWIG_AsVal_double(obj1, &val2);
8816 if (!SWIG_IsOK(ecode2)) {
8817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8818 }
8819 arg2 = static_cast< double >(val2);
8820 }
8821 if (obj2) {
8822 ecode3 = SWIG_AsVal_double(obj2, &val3);
8823 if (!SWIG_IsOK(ecode3)) {
8824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8825 }
8826 arg3 = static_cast< double >(val3);
8827 }
8828 {
8829 PyThreadState* __tstate = wxPyBeginAllowThreads();
8830 wxPoint2D_Set(arg1,arg2,arg3);
8831 wxPyEndAllowThreads(__tstate);
8832 if (PyErr_Occurred()) SWIG_fail;
8833 }
8834 resultobj = SWIG_Py_Void();
8835 return resultobj;
8836 fail:
8837 return NULL;
8838 }
8839
8840
8841 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8842 PyObject *resultobj = 0;
8843 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8844 PyObject *result = 0 ;
8845 void *argp1 = 0 ;
8846 int res1 = 0 ;
8847 PyObject *swig_obj[1] ;
8848
8849 if (!args) SWIG_fail;
8850 swig_obj[0] = args;
8851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8852 if (!SWIG_IsOK(res1)) {
8853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8854 }
8855 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8856 {
8857 PyThreadState* __tstate = wxPyBeginAllowThreads();
8858 result = (PyObject *)wxPoint2D_Get(arg1);
8859 wxPyEndAllowThreads(__tstate);
8860 if (PyErr_Occurred()) SWIG_fail;
8861 }
8862 resultobj = result;
8863 return resultobj;
8864 fail:
8865 return NULL;
8866 }
8867
8868
8869 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8870 PyObject *obj;
8871 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8872 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8873 return SWIG_Py_Void();
8874 }
8875
8876 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8877 return SWIG_Python_InitShadowInstance(args);
8878 }
8879
8880 SWIGINTERN int DefaultPosition_set(PyObject *) {
8881 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8882 return 1;
8883 }
8884
8885
8886 SWIGINTERN PyObject *DefaultPosition_get(void) {
8887 PyObject *pyobj = 0;
8888
8889 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8890 return pyobj;
8891 }
8892
8893
8894 SWIGINTERN int DefaultSize_set(PyObject *) {
8895 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8896 return 1;
8897 }
8898
8899
8900 SWIGINTERN PyObject *DefaultSize_get(void) {
8901 PyObject *pyobj = 0;
8902
8903 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8904 return pyobj;
8905 }
8906
8907
8908 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8909 PyObject *resultobj = 0;
8910 PyObject *arg1 = (PyObject *) 0 ;
8911 wxPyInputStream *result = 0 ;
8912 PyObject * obj0 = 0 ;
8913 char * kwnames[] = {
8914 (char *) "p", NULL
8915 };
8916
8917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8918 arg1 = obj0;
8919 {
8920 PyThreadState* __tstate = wxPyBeginAllowThreads();
8921 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8922 wxPyEndAllowThreads(__tstate);
8923 if (PyErr_Occurred()) SWIG_fail;
8924 }
8925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8926 return resultobj;
8927 fail:
8928 return NULL;
8929 }
8930
8931
8932 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8933 PyObject *resultobj = 0;
8934 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8935 void *argp1 = 0 ;
8936 int res1 = 0 ;
8937 PyObject *swig_obj[1] ;
8938
8939 if (!args) SWIG_fail;
8940 swig_obj[0] = args;
8941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8942 if (!SWIG_IsOK(res1)) {
8943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8944 }
8945 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8946 {
8947 PyThreadState* __tstate = wxPyBeginAllowThreads();
8948 delete arg1;
8949
8950 wxPyEndAllowThreads(__tstate);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 resultobj = SWIG_Py_Void();
8954 return resultobj;
8955 fail:
8956 return NULL;
8957 }
8958
8959
8960 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8961 PyObject *resultobj = 0;
8962 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8963 void *argp1 = 0 ;
8964 int res1 = 0 ;
8965 PyObject *swig_obj[1] ;
8966
8967 if (!args) SWIG_fail;
8968 swig_obj[0] = args;
8969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8970 if (!SWIG_IsOK(res1)) {
8971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8972 }
8973 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8974 {
8975 PyThreadState* __tstate = wxPyBeginAllowThreads();
8976 (arg1)->close();
8977 wxPyEndAllowThreads(__tstate);
8978 if (PyErr_Occurred()) SWIG_fail;
8979 }
8980 resultobj = SWIG_Py_Void();
8981 return resultobj;
8982 fail:
8983 return NULL;
8984 }
8985
8986
8987 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8988 PyObject *resultobj = 0;
8989 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8990 void *argp1 = 0 ;
8991 int res1 = 0 ;
8992 PyObject *swig_obj[1] ;
8993
8994 if (!args) SWIG_fail;
8995 swig_obj[0] = args;
8996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8997 if (!SWIG_IsOK(res1)) {
8998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8999 }
9000 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9001 {
9002 PyThreadState* __tstate = wxPyBeginAllowThreads();
9003 (arg1)->flush();
9004 wxPyEndAllowThreads(__tstate);
9005 if (PyErr_Occurred()) SWIG_fail;
9006 }
9007 resultobj = SWIG_Py_Void();
9008 return resultobj;
9009 fail:
9010 return NULL;
9011 }
9012
9013
9014 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9015 PyObject *resultobj = 0;
9016 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9017 bool result;
9018 void *argp1 = 0 ;
9019 int res1 = 0 ;
9020 PyObject *swig_obj[1] ;
9021
9022 if (!args) SWIG_fail;
9023 swig_obj[0] = args;
9024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9025 if (!SWIG_IsOK(res1)) {
9026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9027 }
9028 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9029 {
9030 PyThreadState* __tstate = wxPyBeginAllowThreads();
9031 result = (bool)(arg1)->eof();
9032 wxPyEndAllowThreads(__tstate);
9033 if (PyErr_Occurred()) SWIG_fail;
9034 }
9035 {
9036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9037 }
9038 return resultobj;
9039 fail:
9040 return NULL;
9041 }
9042
9043
9044 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9045 PyObject *resultobj = 0;
9046 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9047 int arg2 = (int) -1 ;
9048 PyObject *result = 0 ;
9049 void *argp1 = 0 ;
9050 int res1 = 0 ;
9051 int val2 ;
9052 int ecode2 = 0 ;
9053 PyObject * obj0 = 0 ;
9054 PyObject * obj1 = 0 ;
9055 char * kwnames[] = {
9056 (char *) "self",(char *) "size", NULL
9057 };
9058
9059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9061 if (!SWIG_IsOK(res1)) {
9062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9063 }
9064 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9065 if (obj1) {
9066 ecode2 = SWIG_AsVal_int(obj1, &val2);
9067 if (!SWIG_IsOK(ecode2)) {
9068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9069 }
9070 arg2 = static_cast< int >(val2);
9071 }
9072 {
9073 PyThreadState* __tstate = wxPyBeginAllowThreads();
9074 result = (PyObject *)(arg1)->read(arg2);
9075 wxPyEndAllowThreads(__tstate);
9076 if (PyErr_Occurred()) SWIG_fail;
9077 }
9078 resultobj = result;
9079 return resultobj;
9080 fail:
9081 return NULL;
9082 }
9083
9084
9085 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9086 PyObject *resultobj = 0;
9087 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9088 int arg2 = (int) -1 ;
9089 PyObject *result = 0 ;
9090 void *argp1 = 0 ;
9091 int res1 = 0 ;
9092 int val2 ;
9093 int ecode2 = 0 ;
9094 PyObject * obj0 = 0 ;
9095 PyObject * obj1 = 0 ;
9096 char * kwnames[] = {
9097 (char *) "self",(char *) "size", NULL
9098 };
9099
9100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9102 if (!SWIG_IsOK(res1)) {
9103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9104 }
9105 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9106 if (obj1) {
9107 ecode2 = SWIG_AsVal_int(obj1, &val2);
9108 if (!SWIG_IsOK(ecode2)) {
9109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9110 }
9111 arg2 = static_cast< int >(val2);
9112 }
9113 {
9114 PyThreadState* __tstate = wxPyBeginAllowThreads();
9115 result = (PyObject *)(arg1)->readline(arg2);
9116 wxPyEndAllowThreads(__tstate);
9117 if (PyErr_Occurred()) SWIG_fail;
9118 }
9119 resultobj = result;
9120 return resultobj;
9121 fail:
9122 return NULL;
9123 }
9124
9125
9126 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9127 PyObject *resultobj = 0;
9128 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9129 int arg2 = (int) -1 ;
9130 PyObject *result = 0 ;
9131 void *argp1 = 0 ;
9132 int res1 = 0 ;
9133 int val2 ;
9134 int ecode2 = 0 ;
9135 PyObject * obj0 = 0 ;
9136 PyObject * obj1 = 0 ;
9137 char * kwnames[] = {
9138 (char *) "self",(char *) "sizehint", NULL
9139 };
9140
9141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9143 if (!SWIG_IsOK(res1)) {
9144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9145 }
9146 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9147 if (obj1) {
9148 ecode2 = SWIG_AsVal_int(obj1, &val2);
9149 if (!SWIG_IsOK(ecode2)) {
9150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9151 }
9152 arg2 = static_cast< int >(val2);
9153 }
9154 {
9155 PyThreadState* __tstate = wxPyBeginAllowThreads();
9156 result = (PyObject *)(arg1)->readlines(arg2);
9157 wxPyEndAllowThreads(__tstate);
9158 if (PyErr_Occurred()) SWIG_fail;
9159 }
9160 resultobj = result;
9161 return resultobj;
9162 fail:
9163 return NULL;
9164 }
9165
9166
9167 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9168 PyObject *resultobj = 0;
9169 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9170 int arg2 ;
9171 int arg3 = (int) 0 ;
9172 void *argp1 = 0 ;
9173 int res1 = 0 ;
9174 int val2 ;
9175 int ecode2 = 0 ;
9176 int val3 ;
9177 int ecode3 = 0 ;
9178 PyObject * obj0 = 0 ;
9179 PyObject * obj1 = 0 ;
9180 PyObject * obj2 = 0 ;
9181 char * kwnames[] = {
9182 (char *) "self",(char *) "offset",(char *) "whence", NULL
9183 };
9184
9185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9187 if (!SWIG_IsOK(res1)) {
9188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9189 }
9190 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9191 ecode2 = SWIG_AsVal_int(obj1, &val2);
9192 if (!SWIG_IsOK(ecode2)) {
9193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9194 }
9195 arg2 = static_cast< int >(val2);
9196 if (obj2) {
9197 ecode3 = SWIG_AsVal_int(obj2, &val3);
9198 if (!SWIG_IsOK(ecode3)) {
9199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9200 }
9201 arg3 = static_cast< int >(val3);
9202 }
9203 {
9204 PyThreadState* __tstate = wxPyBeginAllowThreads();
9205 (arg1)->seek(arg2,arg3);
9206 wxPyEndAllowThreads(__tstate);
9207 if (PyErr_Occurred()) SWIG_fail;
9208 }
9209 resultobj = SWIG_Py_Void();
9210 return resultobj;
9211 fail:
9212 return NULL;
9213 }
9214
9215
9216 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9217 PyObject *resultobj = 0;
9218 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9219 int result;
9220 void *argp1 = 0 ;
9221 int res1 = 0 ;
9222 PyObject *swig_obj[1] ;
9223
9224 if (!args) SWIG_fail;
9225 swig_obj[0] = args;
9226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9227 if (!SWIG_IsOK(res1)) {
9228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9229 }
9230 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9231 {
9232 PyThreadState* __tstate = wxPyBeginAllowThreads();
9233 result = (int)(arg1)->tell();
9234 wxPyEndAllowThreads(__tstate);
9235 if (PyErr_Occurred()) SWIG_fail;
9236 }
9237 resultobj = SWIG_From_int(static_cast< int >(result));
9238 return resultobj;
9239 fail:
9240 return NULL;
9241 }
9242
9243
9244 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9245 PyObject *resultobj = 0;
9246 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9247 char result;
9248 void *argp1 = 0 ;
9249 int res1 = 0 ;
9250 PyObject *swig_obj[1] ;
9251
9252 if (!args) SWIG_fail;
9253 swig_obj[0] = args;
9254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9255 if (!SWIG_IsOK(res1)) {
9256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9257 }
9258 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9259 {
9260 PyThreadState* __tstate = wxPyBeginAllowThreads();
9261 result = (char)(arg1)->Peek();
9262 wxPyEndAllowThreads(__tstate);
9263 if (PyErr_Occurred()) SWIG_fail;
9264 }
9265 resultobj = SWIG_From_char(static_cast< char >(result));
9266 return resultobj;
9267 fail:
9268 return NULL;
9269 }
9270
9271
9272 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9273 PyObject *resultobj = 0;
9274 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9275 char result;
9276 void *argp1 = 0 ;
9277 int res1 = 0 ;
9278 PyObject *swig_obj[1] ;
9279
9280 if (!args) SWIG_fail;
9281 swig_obj[0] = args;
9282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9283 if (!SWIG_IsOK(res1)) {
9284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9285 }
9286 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9287 {
9288 PyThreadState* __tstate = wxPyBeginAllowThreads();
9289 result = (char)(arg1)->GetC();
9290 wxPyEndAllowThreads(__tstate);
9291 if (PyErr_Occurred()) SWIG_fail;
9292 }
9293 resultobj = SWIG_From_char(static_cast< char >(result));
9294 return resultobj;
9295 fail:
9296 return NULL;
9297 }
9298
9299
9300 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9301 PyObject *resultobj = 0;
9302 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9303 size_t result;
9304 void *argp1 = 0 ;
9305 int res1 = 0 ;
9306 PyObject *swig_obj[1] ;
9307
9308 if (!args) SWIG_fail;
9309 swig_obj[0] = args;
9310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9311 if (!SWIG_IsOK(res1)) {
9312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9313 }
9314 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9315 {
9316 PyThreadState* __tstate = wxPyBeginAllowThreads();
9317 result = (size_t)(arg1)->LastRead();
9318 wxPyEndAllowThreads(__tstate);
9319 if (PyErr_Occurred()) SWIG_fail;
9320 }
9321 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9322 return resultobj;
9323 fail:
9324 return NULL;
9325 }
9326
9327
9328 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9329 PyObject *resultobj = 0;
9330 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9331 bool result;
9332 void *argp1 = 0 ;
9333 int res1 = 0 ;
9334 PyObject *swig_obj[1] ;
9335
9336 if (!args) SWIG_fail;
9337 swig_obj[0] = args;
9338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9339 if (!SWIG_IsOK(res1)) {
9340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9341 }
9342 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9343 {
9344 PyThreadState* __tstate = wxPyBeginAllowThreads();
9345 result = (bool)(arg1)->CanRead();
9346 wxPyEndAllowThreads(__tstate);
9347 if (PyErr_Occurred()) SWIG_fail;
9348 }
9349 {
9350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9351 }
9352 return resultobj;
9353 fail:
9354 return NULL;
9355 }
9356
9357
9358 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9359 PyObject *resultobj = 0;
9360 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9361 bool result;
9362 void *argp1 = 0 ;
9363 int res1 = 0 ;
9364 PyObject *swig_obj[1] ;
9365
9366 if (!args) SWIG_fail;
9367 swig_obj[0] = args;
9368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9369 if (!SWIG_IsOK(res1)) {
9370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9371 }
9372 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9373 {
9374 PyThreadState* __tstate = wxPyBeginAllowThreads();
9375 result = (bool)(arg1)->Eof();
9376 wxPyEndAllowThreads(__tstate);
9377 if (PyErr_Occurred()) SWIG_fail;
9378 }
9379 {
9380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9381 }
9382 return resultobj;
9383 fail:
9384 return NULL;
9385 }
9386
9387
9388 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9389 PyObject *resultobj = 0;
9390 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9391 char arg2 ;
9392 bool result;
9393 void *argp1 = 0 ;
9394 int res1 = 0 ;
9395 char val2 ;
9396 int ecode2 = 0 ;
9397 PyObject * obj0 = 0 ;
9398 PyObject * obj1 = 0 ;
9399 char * kwnames[] = {
9400 (char *) "self",(char *) "c", NULL
9401 };
9402
9403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9405 if (!SWIG_IsOK(res1)) {
9406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9407 }
9408 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9409 ecode2 = SWIG_AsVal_char(obj1, &val2);
9410 if (!SWIG_IsOK(ecode2)) {
9411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9412 }
9413 arg2 = static_cast< char >(val2);
9414 {
9415 PyThreadState* __tstate = wxPyBeginAllowThreads();
9416 result = (bool)(arg1)->Ungetch(arg2);
9417 wxPyEndAllowThreads(__tstate);
9418 if (PyErr_Occurred()) SWIG_fail;
9419 }
9420 {
9421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9422 }
9423 return resultobj;
9424 fail:
9425 return NULL;
9426 }
9427
9428
9429 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9430 PyObject *resultobj = 0;
9431 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9432 long arg2 ;
9433 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9434 long result;
9435 void *argp1 = 0 ;
9436 int res1 = 0 ;
9437 long val2 ;
9438 int ecode2 = 0 ;
9439 int val3 ;
9440 int ecode3 = 0 ;
9441 PyObject * obj0 = 0 ;
9442 PyObject * obj1 = 0 ;
9443 PyObject * obj2 = 0 ;
9444 char * kwnames[] = {
9445 (char *) "self",(char *) "pos",(char *) "mode", NULL
9446 };
9447
9448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9450 if (!SWIG_IsOK(res1)) {
9451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9452 }
9453 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9454 ecode2 = SWIG_AsVal_long(obj1, &val2);
9455 if (!SWIG_IsOK(ecode2)) {
9456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9457 }
9458 arg2 = static_cast< long >(val2);
9459 if (obj2) {
9460 ecode3 = SWIG_AsVal_int(obj2, &val3);
9461 if (!SWIG_IsOK(ecode3)) {
9462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9463 }
9464 arg3 = static_cast< wxSeekMode >(val3);
9465 }
9466 {
9467 PyThreadState* __tstate = wxPyBeginAllowThreads();
9468 result = (long)(arg1)->SeekI(arg2,arg3);
9469 wxPyEndAllowThreads(__tstate);
9470 if (PyErr_Occurred()) SWIG_fail;
9471 }
9472 resultobj = SWIG_From_long(static_cast< long >(result));
9473 return resultobj;
9474 fail:
9475 return NULL;
9476 }
9477
9478
9479 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9480 PyObject *resultobj = 0;
9481 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9482 long result;
9483 void *argp1 = 0 ;
9484 int res1 = 0 ;
9485 PyObject *swig_obj[1] ;
9486
9487 if (!args) SWIG_fail;
9488 swig_obj[0] = args;
9489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9490 if (!SWIG_IsOK(res1)) {
9491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9492 }
9493 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9494 {
9495 PyThreadState* __tstate = wxPyBeginAllowThreads();
9496 result = (long)(arg1)->TellI();
9497 wxPyEndAllowThreads(__tstate);
9498 if (PyErr_Occurred()) SWIG_fail;
9499 }
9500 resultobj = SWIG_From_long(static_cast< long >(result));
9501 return resultobj;
9502 fail:
9503 return NULL;
9504 }
9505
9506
9507 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9508 PyObject *obj;
9509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9510 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9511 return SWIG_Py_Void();
9512 }
9513
9514 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9515 return SWIG_Python_InitShadowInstance(args);
9516 }
9517
9518 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9519 PyObject *resultobj = 0;
9520 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9521 PyObject *arg2 = (PyObject *) 0 ;
9522 void *argp1 = 0 ;
9523 int res1 = 0 ;
9524 PyObject * obj0 = 0 ;
9525 PyObject * obj1 = 0 ;
9526 char * kwnames[] = {
9527 (char *) "self",(char *) "obj", NULL
9528 };
9529
9530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9532 if (!SWIG_IsOK(res1)) {
9533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9534 }
9535 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9536 arg2 = obj1;
9537 {
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 wxOutputStream_write(arg1,arg2);
9540 wxPyEndAllowThreads(__tstate);
9541 if (PyErr_Occurred()) SWIG_fail;
9542 }
9543 resultobj = SWIG_Py_Void();
9544 return resultobj;
9545 fail:
9546 return NULL;
9547 }
9548
9549
9550 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9551 PyObject *resultobj = 0;
9552 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9553 size_t result;
9554 void *argp1 = 0 ;
9555 int res1 = 0 ;
9556 PyObject *swig_obj[1] ;
9557
9558 if (!args) SWIG_fail;
9559 swig_obj[0] = args;
9560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9561 if (!SWIG_IsOK(res1)) {
9562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9563 }
9564 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9565 {
9566 PyThreadState* __tstate = wxPyBeginAllowThreads();
9567 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9568 wxPyEndAllowThreads(__tstate);
9569 if (PyErr_Occurred()) SWIG_fail;
9570 }
9571 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9572 return resultobj;
9573 fail:
9574 return NULL;
9575 }
9576
9577
9578 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9579 PyObject *obj;
9580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9581 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9582 return SWIG_Py_Void();
9583 }
9584
9585 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9586 PyObject *resultobj = 0;
9587 wxInputStream *arg1 = (wxInputStream *) 0 ;
9588 wxString *arg2 = 0 ;
9589 wxString *arg3 = 0 ;
9590 wxString *arg4 = 0 ;
9591 wxDateTime arg5 ;
9592 wxFSFile *result = 0 ;
9593 wxPyInputStream *temp1 ;
9594 bool temp2 = false ;
9595 bool temp3 = false ;
9596 bool temp4 = false ;
9597 void *argp5 ;
9598 int res5 = 0 ;
9599 PyObject * obj0 = 0 ;
9600 PyObject * obj1 = 0 ;
9601 PyObject * obj2 = 0 ;
9602 PyObject * obj3 = 0 ;
9603 PyObject * obj4 = 0 ;
9604 char * kwnames[] = {
9605 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9606 };
9607
9608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9609 {
9610 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9611 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9612 } else {
9613 PyErr_Clear(); // clear the failure of the wxPyConvert above
9614 arg1 = wxPyCBInputStream_create(obj0, true);
9615 if (arg1 == NULL) {
9616 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9617 SWIG_fail;
9618 }
9619 }
9620 }
9621 {
9622 arg2 = wxString_in_helper(obj1);
9623 if (arg2 == NULL) SWIG_fail;
9624 temp2 = true;
9625 }
9626 {
9627 arg3 = wxString_in_helper(obj2);
9628 if (arg3 == NULL) SWIG_fail;
9629 temp3 = true;
9630 }
9631 {
9632 arg4 = wxString_in_helper(obj3);
9633 if (arg4 == NULL) SWIG_fail;
9634 temp4 = true;
9635 }
9636 {
9637 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9638 if (!SWIG_IsOK(res5)) {
9639 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9640 }
9641 if (!argp5) {
9642 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9643 } else {
9644 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9645 arg5 = *temp;
9646 if (SWIG_IsNewObj(res5)) delete temp;
9647 }
9648 }
9649 {
9650 PyThreadState* __tstate = wxPyBeginAllowThreads();
9651 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9652 wxPyEndAllowThreads(__tstate);
9653 if (PyErr_Occurred()) SWIG_fail;
9654 }
9655 {
9656 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9657 }
9658 {
9659 if (temp2)
9660 delete arg2;
9661 }
9662 {
9663 if (temp3)
9664 delete arg3;
9665 }
9666 {
9667 if (temp4)
9668 delete arg4;
9669 }
9670 return resultobj;
9671 fail:
9672 {
9673 if (temp2)
9674 delete arg2;
9675 }
9676 {
9677 if (temp3)
9678 delete arg3;
9679 }
9680 {
9681 if (temp4)
9682 delete arg4;
9683 }
9684 return NULL;
9685 }
9686
9687
9688 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9689 PyObject *resultobj = 0;
9690 wxFSFile *arg1 = (wxFSFile *) 0 ;
9691 void *argp1 = 0 ;
9692 int res1 = 0 ;
9693 PyObject *swig_obj[1] ;
9694
9695 if (!args) SWIG_fail;
9696 swig_obj[0] = args;
9697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9698 if (!SWIG_IsOK(res1)) {
9699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9700 }
9701 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9702 {
9703 PyThreadState* __tstate = wxPyBeginAllowThreads();
9704 delete arg1;
9705
9706 wxPyEndAllowThreads(__tstate);
9707 if (PyErr_Occurred()) SWIG_fail;
9708 }
9709 resultobj = SWIG_Py_Void();
9710 return resultobj;
9711 fail:
9712 return NULL;
9713 }
9714
9715
9716 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9717 PyObject *resultobj = 0;
9718 wxFSFile *arg1 = (wxFSFile *) 0 ;
9719 wxInputStream *result = 0 ;
9720 void *argp1 = 0 ;
9721 int res1 = 0 ;
9722 PyObject *swig_obj[1] ;
9723
9724 if (!args) SWIG_fail;
9725 swig_obj[0] = args;
9726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9727 if (!SWIG_IsOK(res1)) {
9728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9729 }
9730 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9731 {
9732 PyThreadState* __tstate = wxPyBeginAllowThreads();
9733 result = (wxInputStream *)(arg1)->GetStream();
9734 wxPyEndAllowThreads(__tstate);
9735 if (PyErr_Occurred()) SWIG_fail;
9736 }
9737 {
9738 wxPyInputStream * _ptr = NULL;
9739
9740 if (result) {
9741 _ptr = new wxPyInputStream(result);
9742 }
9743 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9744 }
9745 return resultobj;
9746 fail:
9747 return NULL;
9748 }
9749
9750
9751 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9752 PyObject *resultobj = 0;
9753 wxFSFile *arg1 = (wxFSFile *) 0 ;
9754 wxString *result = 0 ;
9755 void *argp1 = 0 ;
9756 int res1 = 0 ;
9757 PyObject *swig_obj[1] ;
9758
9759 if (!args) SWIG_fail;
9760 swig_obj[0] = args;
9761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9762 if (!SWIG_IsOK(res1)) {
9763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9764 }
9765 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9766 {
9767 PyThreadState* __tstate = wxPyBeginAllowThreads();
9768 {
9769 wxString const &_result_ref = (arg1)->GetMimeType();
9770 result = (wxString *) &_result_ref;
9771 }
9772 wxPyEndAllowThreads(__tstate);
9773 if (PyErr_Occurred()) SWIG_fail;
9774 }
9775 {
9776 #if wxUSE_UNICODE
9777 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9778 #else
9779 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9780 #endif
9781 }
9782 return resultobj;
9783 fail:
9784 return NULL;
9785 }
9786
9787
9788 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9789 PyObject *resultobj = 0;
9790 wxFSFile *arg1 = (wxFSFile *) 0 ;
9791 wxString *result = 0 ;
9792 void *argp1 = 0 ;
9793 int res1 = 0 ;
9794 PyObject *swig_obj[1] ;
9795
9796 if (!args) SWIG_fail;
9797 swig_obj[0] = args;
9798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9799 if (!SWIG_IsOK(res1)) {
9800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9801 }
9802 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9803 {
9804 PyThreadState* __tstate = wxPyBeginAllowThreads();
9805 {
9806 wxString const &_result_ref = (arg1)->GetLocation();
9807 result = (wxString *) &_result_ref;
9808 }
9809 wxPyEndAllowThreads(__tstate);
9810 if (PyErr_Occurred()) SWIG_fail;
9811 }
9812 {
9813 #if wxUSE_UNICODE
9814 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9815 #else
9816 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9817 #endif
9818 }
9819 return resultobj;
9820 fail:
9821 return NULL;
9822 }
9823
9824
9825 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9826 PyObject *resultobj = 0;
9827 wxFSFile *arg1 = (wxFSFile *) 0 ;
9828 wxString *result = 0 ;
9829 void *argp1 = 0 ;
9830 int res1 = 0 ;
9831 PyObject *swig_obj[1] ;
9832
9833 if (!args) SWIG_fail;
9834 swig_obj[0] = args;
9835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9836 if (!SWIG_IsOK(res1)) {
9837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9838 }
9839 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9840 {
9841 PyThreadState* __tstate = wxPyBeginAllowThreads();
9842 {
9843 wxString const &_result_ref = (arg1)->GetAnchor();
9844 result = (wxString *) &_result_ref;
9845 }
9846 wxPyEndAllowThreads(__tstate);
9847 if (PyErr_Occurred()) SWIG_fail;
9848 }
9849 {
9850 #if wxUSE_UNICODE
9851 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9852 #else
9853 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9854 #endif
9855 }
9856 return resultobj;
9857 fail:
9858 return NULL;
9859 }
9860
9861
9862 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9863 PyObject *resultobj = 0;
9864 wxFSFile *arg1 = (wxFSFile *) 0 ;
9865 wxDateTime result;
9866 void *argp1 = 0 ;
9867 int res1 = 0 ;
9868 PyObject *swig_obj[1] ;
9869
9870 if (!args) SWIG_fail;
9871 swig_obj[0] = args;
9872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9873 if (!SWIG_IsOK(res1)) {
9874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9875 }
9876 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9877 {
9878 PyThreadState* __tstate = wxPyBeginAllowThreads();
9879 result = (arg1)->GetModificationTime();
9880 wxPyEndAllowThreads(__tstate);
9881 if (PyErr_Occurred()) SWIG_fail;
9882 }
9883 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9884 return resultobj;
9885 fail:
9886 return NULL;
9887 }
9888
9889
9890 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9891 PyObject *obj;
9892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9893 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9894 return SWIG_Py_Void();
9895 }
9896
9897 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9898 return SWIG_Python_InitShadowInstance(args);
9899 }
9900
9901 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9902 PyObject *resultobj = 0;
9903 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9904 void *argp1 = 0 ;
9905 int res1 = 0 ;
9906 PyObject *swig_obj[1] ;
9907
9908 if (!args) SWIG_fail;
9909 swig_obj[0] = args;
9910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9911 if (!SWIG_IsOK(res1)) {
9912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9913 }
9914 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9915 {
9916 PyThreadState* __tstate = wxPyBeginAllowThreads();
9917 delete arg1;
9918
9919 wxPyEndAllowThreads(__tstate);
9920 if (PyErr_Occurred()) SWIG_fail;
9921 }
9922 resultobj = SWIG_Py_Void();
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9930 PyObject *obj;
9931 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9932 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9933 return SWIG_Py_Void();
9934 }
9935
9936 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9937 PyObject *resultobj = 0;
9938 wxPyFileSystemHandler *result = 0 ;
9939
9940 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9941 {
9942 PyThreadState* __tstate = wxPyBeginAllowThreads();
9943 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9944 wxPyEndAllowThreads(__tstate);
9945 if (PyErr_Occurred()) SWIG_fail;
9946 }
9947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9948 return resultobj;
9949 fail:
9950 return NULL;
9951 }
9952
9953
9954 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9955 PyObject *resultobj = 0;
9956 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9957 PyObject *arg2 = (PyObject *) 0 ;
9958 PyObject *arg3 = (PyObject *) 0 ;
9959 void *argp1 = 0 ;
9960 int res1 = 0 ;
9961 PyObject * obj0 = 0 ;
9962 PyObject * obj1 = 0 ;
9963 PyObject * obj2 = 0 ;
9964 char * kwnames[] = {
9965 (char *) "self",(char *) "self",(char *) "_class", NULL
9966 };
9967
9968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9970 if (!SWIG_IsOK(res1)) {
9971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9972 }
9973 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9974 arg2 = obj1;
9975 arg3 = obj2;
9976 {
9977 PyThreadState* __tstate = wxPyBeginAllowThreads();
9978 (arg1)->_setCallbackInfo(arg2,arg3);
9979 wxPyEndAllowThreads(__tstate);
9980 if (PyErr_Occurred()) SWIG_fail;
9981 }
9982 resultobj = SWIG_Py_Void();
9983 return resultobj;
9984 fail:
9985 return NULL;
9986 }
9987
9988
9989 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9990 PyObject *resultobj = 0;
9991 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9992 wxString *arg2 = 0 ;
9993 bool result;
9994 void *argp1 = 0 ;
9995 int res1 = 0 ;
9996 bool temp2 = false ;
9997 PyObject * obj0 = 0 ;
9998 PyObject * obj1 = 0 ;
9999 char * kwnames[] = {
10000 (char *) "self",(char *) "location", NULL
10001 };
10002
10003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10005 if (!SWIG_IsOK(res1)) {
10006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10007 }
10008 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10009 {
10010 arg2 = wxString_in_helper(obj1);
10011 if (arg2 == NULL) SWIG_fail;
10012 temp2 = true;
10013 }
10014 {
10015 PyThreadState* __tstate = wxPyBeginAllowThreads();
10016 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10017 wxPyEndAllowThreads(__tstate);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 {
10021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10022 }
10023 {
10024 if (temp2)
10025 delete arg2;
10026 }
10027 return resultobj;
10028 fail:
10029 {
10030 if (temp2)
10031 delete arg2;
10032 }
10033 return NULL;
10034 }
10035
10036
10037 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10038 PyObject *resultobj = 0;
10039 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10040 wxFileSystem *arg2 = 0 ;
10041 wxString *arg3 = 0 ;
10042 wxFSFile *result = 0 ;
10043 void *argp1 = 0 ;
10044 int res1 = 0 ;
10045 void *argp2 = 0 ;
10046 int res2 = 0 ;
10047 bool temp3 = false ;
10048 PyObject * obj0 = 0 ;
10049 PyObject * obj1 = 0 ;
10050 PyObject * obj2 = 0 ;
10051 char * kwnames[] = {
10052 (char *) "self",(char *) "fs",(char *) "location", NULL
10053 };
10054
10055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10057 if (!SWIG_IsOK(res1)) {
10058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10059 }
10060 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10061 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10062 if (!SWIG_IsOK(res2)) {
10063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10064 }
10065 if (!argp2) {
10066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10067 }
10068 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10069 {
10070 arg3 = wxString_in_helper(obj2);
10071 if (arg3 == NULL) SWIG_fail;
10072 temp3 = true;
10073 }
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10077 wxPyEndAllowThreads(__tstate);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 {
10081 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10082 }
10083 {
10084 if (temp3)
10085 delete arg3;
10086 }
10087 return resultobj;
10088 fail:
10089 {
10090 if (temp3)
10091 delete arg3;
10092 }
10093 return NULL;
10094 }
10095
10096
10097 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10098 PyObject *resultobj = 0;
10099 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10100 wxString *arg2 = 0 ;
10101 int arg3 = (int) 0 ;
10102 wxString result;
10103 void *argp1 = 0 ;
10104 int res1 = 0 ;
10105 bool temp2 = false ;
10106 int val3 ;
10107 int ecode3 = 0 ;
10108 PyObject * obj0 = 0 ;
10109 PyObject * obj1 = 0 ;
10110 PyObject * obj2 = 0 ;
10111 char * kwnames[] = {
10112 (char *) "self",(char *) "spec",(char *) "flags", NULL
10113 };
10114
10115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10117 if (!SWIG_IsOK(res1)) {
10118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10119 }
10120 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10121 {
10122 arg2 = wxString_in_helper(obj1);
10123 if (arg2 == NULL) SWIG_fail;
10124 temp2 = true;
10125 }
10126 if (obj2) {
10127 ecode3 = SWIG_AsVal_int(obj2, &val3);
10128 if (!SWIG_IsOK(ecode3)) {
10129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10130 }
10131 arg3 = static_cast< int >(val3);
10132 }
10133 {
10134 PyThreadState* __tstate = wxPyBeginAllowThreads();
10135 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10136 wxPyEndAllowThreads(__tstate);
10137 if (PyErr_Occurred()) SWIG_fail;
10138 }
10139 {
10140 #if wxUSE_UNICODE
10141 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10142 #else
10143 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10144 #endif
10145 }
10146 {
10147 if (temp2)
10148 delete arg2;
10149 }
10150 return resultobj;
10151 fail:
10152 {
10153 if (temp2)
10154 delete arg2;
10155 }
10156 return NULL;
10157 }
10158
10159
10160 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10161 PyObject *resultobj = 0;
10162 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10163 wxString result;
10164 void *argp1 = 0 ;
10165 int res1 = 0 ;
10166 PyObject *swig_obj[1] ;
10167
10168 if (!args) SWIG_fail;
10169 swig_obj[0] = args;
10170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10171 if (!SWIG_IsOK(res1)) {
10172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10173 }
10174 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10175 {
10176 PyThreadState* __tstate = wxPyBeginAllowThreads();
10177 result = (arg1)->FindNext();
10178 wxPyEndAllowThreads(__tstate);
10179 if (PyErr_Occurred()) SWIG_fail;
10180 }
10181 {
10182 #if wxUSE_UNICODE
10183 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10184 #else
10185 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10186 #endif
10187 }
10188 return resultobj;
10189 fail:
10190 return NULL;
10191 }
10192
10193
10194 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10195 PyObject *resultobj = 0;
10196 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10197 wxString *arg2 = 0 ;
10198 wxString result;
10199 void *argp1 = 0 ;
10200 int res1 = 0 ;
10201 bool temp2 = false ;
10202 PyObject * obj0 = 0 ;
10203 PyObject * obj1 = 0 ;
10204 char * kwnames[] = {
10205 (char *) "self",(char *) "location", NULL
10206 };
10207
10208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10210 if (!SWIG_IsOK(res1)) {
10211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10212 }
10213 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10214 {
10215 arg2 = wxString_in_helper(obj1);
10216 if (arg2 == NULL) SWIG_fail;
10217 temp2 = true;
10218 }
10219 {
10220 PyThreadState* __tstate = wxPyBeginAllowThreads();
10221 result = (arg1)->GetProtocol((wxString const &)*arg2);
10222 wxPyEndAllowThreads(__tstate);
10223 if (PyErr_Occurred()) SWIG_fail;
10224 }
10225 {
10226 #if wxUSE_UNICODE
10227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10228 #else
10229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10230 #endif
10231 }
10232 {
10233 if (temp2)
10234 delete arg2;
10235 }
10236 return resultobj;
10237 fail:
10238 {
10239 if (temp2)
10240 delete arg2;
10241 }
10242 return NULL;
10243 }
10244
10245
10246 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10247 PyObject *resultobj = 0;
10248 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10249 wxString *arg2 = 0 ;
10250 wxString result;
10251 void *argp1 = 0 ;
10252 int res1 = 0 ;
10253 bool temp2 = false ;
10254 PyObject * obj0 = 0 ;
10255 PyObject * obj1 = 0 ;
10256 char * kwnames[] = {
10257 (char *) "self",(char *) "location", NULL
10258 };
10259
10260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10262 if (!SWIG_IsOK(res1)) {
10263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10264 }
10265 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10266 {
10267 arg2 = wxString_in_helper(obj1);
10268 if (arg2 == NULL) SWIG_fail;
10269 temp2 = true;
10270 }
10271 {
10272 PyThreadState* __tstate = wxPyBeginAllowThreads();
10273 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10274 wxPyEndAllowThreads(__tstate);
10275 if (PyErr_Occurred()) SWIG_fail;
10276 }
10277 {
10278 #if wxUSE_UNICODE
10279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10280 #else
10281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10282 #endif
10283 }
10284 {
10285 if (temp2)
10286 delete arg2;
10287 }
10288 return resultobj;
10289 fail:
10290 {
10291 if (temp2)
10292 delete arg2;
10293 }
10294 return NULL;
10295 }
10296
10297
10298 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10299 PyObject *resultobj = 0;
10300 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10301 wxString *arg2 = 0 ;
10302 wxString result;
10303 void *argp1 = 0 ;
10304 int res1 = 0 ;
10305 bool temp2 = false ;
10306 PyObject * obj0 = 0 ;
10307 PyObject * obj1 = 0 ;
10308 char * kwnames[] = {
10309 (char *) "self",(char *) "location", NULL
10310 };
10311
10312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10314 if (!SWIG_IsOK(res1)) {
10315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10316 }
10317 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10318 {
10319 arg2 = wxString_in_helper(obj1);
10320 if (arg2 == NULL) SWIG_fail;
10321 temp2 = true;
10322 }
10323 {
10324 PyThreadState* __tstate = wxPyBeginAllowThreads();
10325 result = (arg1)->GetAnchor((wxString const &)*arg2);
10326 wxPyEndAllowThreads(__tstate);
10327 if (PyErr_Occurred()) SWIG_fail;
10328 }
10329 {
10330 #if wxUSE_UNICODE
10331 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10332 #else
10333 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10334 #endif
10335 }
10336 {
10337 if (temp2)
10338 delete arg2;
10339 }
10340 return resultobj;
10341 fail:
10342 {
10343 if (temp2)
10344 delete arg2;
10345 }
10346 return NULL;
10347 }
10348
10349
10350 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10351 PyObject *resultobj = 0;
10352 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10353 wxString *arg2 = 0 ;
10354 wxString result;
10355 void *argp1 = 0 ;
10356 int res1 = 0 ;
10357 bool temp2 = false ;
10358 PyObject * obj0 = 0 ;
10359 PyObject * obj1 = 0 ;
10360 char * kwnames[] = {
10361 (char *) "self",(char *) "location", NULL
10362 };
10363
10364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10366 if (!SWIG_IsOK(res1)) {
10367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10368 }
10369 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10370 {
10371 arg2 = wxString_in_helper(obj1);
10372 if (arg2 == NULL) SWIG_fail;
10373 temp2 = true;
10374 }
10375 {
10376 PyThreadState* __tstate = wxPyBeginAllowThreads();
10377 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10378 wxPyEndAllowThreads(__tstate);
10379 if (PyErr_Occurred()) SWIG_fail;
10380 }
10381 {
10382 #if wxUSE_UNICODE
10383 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10384 #else
10385 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10386 #endif
10387 }
10388 {
10389 if (temp2)
10390 delete arg2;
10391 }
10392 return resultobj;
10393 fail:
10394 {
10395 if (temp2)
10396 delete arg2;
10397 }
10398 return NULL;
10399 }
10400
10401
10402 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10403 PyObject *resultobj = 0;
10404 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10405 wxString *arg2 = 0 ;
10406 wxString result;
10407 void *argp1 = 0 ;
10408 int res1 = 0 ;
10409 bool temp2 = false ;
10410 PyObject * obj0 = 0 ;
10411 PyObject * obj1 = 0 ;
10412 char * kwnames[] = {
10413 (char *) "self",(char *) "location", NULL
10414 };
10415
10416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10418 if (!SWIG_IsOK(res1)) {
10419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10420 }
10421 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10422 {
10423 arg2 = wxString_in_helper(obj1);
10424 if (arg2 == NULL) SWIG_fail;
10425 temp2 = true;
10426 }
10427 {
10428 PyThreadState* __tstate = wxPyBeginAllowThreads();
10429 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10430 wxPyEndAllowThreads(__tstate);
10431 if (PyErr_Occurred()) SWIG_fail;
10432 }
10433 {
10434 #if wxUSE_UNICODE
10435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10436 #else
10437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10438 #endif
10439 }
10440 {
10441 if (temp2)
10442 delete arg2;
10443 }
10444 return resultobj;
10445 fail:
10446 {
10447 if (temp2)
10448 delete arg2;
10449 }
10450 return NULL;
10451 }
10452
10453
10454 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10455 PyObject *obj;
10456 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10457 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10458 return SWIG_Py_Void();
10459 }
10460
10461 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10462 return SWIG_Python_InitShadowInstance(args);
10463 }
10464
10465 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10466 PyObject *resultobj = 0;
10467 wxFileSystem *result = 0 ;
10468
10469 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10470 {
10471 PyThreadState* __tstate = wxPyBeginAllowThreads();
10472 result = (wxFileSystem *)new wxFileSystem();
10473 wxPyEndAllowThreads(__tstate);
10474 if (PyErr_Occurred()) SWIG_fail;
10475 }
10476 {
10477 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10478 }
10479 return resultobj;
10480 fail:
10481 return NULL;
10482 }
10483
10484
10485 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10486 PyObject *resultobj = 0;
10487 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10488 void *argp1 = 0 ;
10489 int res1 = 0 ;
10490 PyObject *swig_obj[1] ;
10491
10492 if (!args) SWIG_fail;
10493 swig_obj[0] = args;
10494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10495 if (!SWIG_IsOK(res1)) {
10496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10497 }
10498 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10499 {
10500 PyThreadState* __tstate = wxPyBeginAllowThreads();
10501 delete arg1;
10502
10503 wxPyEndAllowThreads(__tstate);
10504 if (PyErr_Occurred()) SWIG_fail;
10505 }
10506 resultobj = SWIG_Py_Void();
10507 return resultobj;
10508 fail:
10509 return NULL;
10510 }
10511
10512
10513 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10514 PyObject *resultobj = 0;
10515 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10516 wxString *arg2 = 0 ;
10517 bool arg3 = (bool) false ;
10518 void *argp1 = 0 ;
10519 int res1 = 0 ;
10520 bool temp2 = false ;
10521 bool val3 ;
10522 int ecode3 = 0 ;
10523 PyObject * obj0 = 0 ;
10524 PyObject * obj1 = 0 ;
10525 PyObject * obj2 = 0 ;
10526 char * kwnames[] = {
10527 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10528 };
10529
10530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10532 if (!SWIG_IsOK(res1)) {
10533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10534 }
10535 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10536 {
10537 arg2 = wxString_in_helper(obj1);
10538 if (arg2 == NULL) SWIG_fail;
10539 temp2 = true;
10540 }
10541 if (obj2) {
10542 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10543 if (!SWIG_IsOK(ecode3)) {
10544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10545 }
10546 arg3 = static_cast< bool >(val3);
10547 }
10548 {
10549 PyThreadState* __tstate = wxPyBeginAllowThreads();
10550 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 resultobj = SWIG_Py_Void();
10555 {
10556 if (temp2)
10557 delete arg2;
10558 }
10559 return resultobj;
10560 fail:
10561 {
10562 if (temp2)
10563 delete arg2;
10564 }
10565 return NULL;
10566 }
10567
10568
10569 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10570 PyObject *resultobj = 0;
10571 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10572 wxString result;
10573 void *argp1 = 0 ;
10574 int res1 = 0 ;
10575 PyObject *swig_obj[1] ;
10576
10577 if (!args) SWIG_fail;
10578 swig_obj[0] = args;
10579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10580 if (!SWIG_IsOK(res1)) {
10581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10582 }
10583 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10584 {
10585 PyThreadState* __tstate = wxPyBeginAllowThreads();
10586 result = (arg1)->GetPath();
10587 wxPyEndAllowThreads(__tstate);
10588 if (PyErr_Occurred()) SWIG_fail;
10589 }
10590 {
10591 #if wxUSE_UNICODE
10592 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10593 #else
10594 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10595 #endif
10596 }
10597 return resultobj;
10598 fail:
10599 return NULL;
10600 }
10601
10602
10603 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10604 PyObject *resultobj = 0;
10605 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10606 wxString *arg2 = 0 ;
10607 wxFSFile *result = 0 ;
10608 void *argp1 = 0 ;
10609 int res1 = 0 ;
10610 bool temp2 = false ;
10611 PyObject * obj0 = 0 ;
10612 PyObject * obj1 = 0 ;
10613 char * kwnames[] = {
10614 (char *) "self",(char *) "location", NULL
10615 };
10616
10617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10619 if (!SWIG_IsOK(res1)) {
10620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10621 }
10622 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10623 {
10624 arg2 = wxString_in_helper(obj1);
10625 if (arg2 == NULL) SWIG_fail;
10626 temp2 = true;
10627 }
10628 {
10629 PyThreadState* __tstate = wxPyBeginAllowThreads();
10630 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10631 wxPyEndAllowThreads(__tstate);
10632 if (PyErr_Occurred()) SWIG_fail;
10633 }
10634 {
10635 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10636 }
10637 {
10638 if (temp2)
10639 delete arg2;
10640 }
10641 return resultobj;
10642 fail:
10643 {
10644 if (temp2)
10645 delete arg2;
10646 }
10647 return NULL;
10648 }
10649
10650
10651 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10652 PyObject *resultobj = 0;
10653 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10654 wxString *arg2 = 0 ;
10655 int arg3 = (int) 0 ;
10656 wxString result;
10657 void *argp1 = 0 ;
10658 int res1 = 0 ;
10659 bool temp2 = false ;
10660 int val3 ;
10661 int ecode3 = 0 ;
10662 PyObject * obj0 = 0 ;
10663 PyObject * obj1 = 0 ;
10664 PyObject * obj2 = 0 ;
10665 char * kwnames[] = {
10666 (char *) "self",(char *) "spec",(char *) "flags", NULL
10667 };
10668
10669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10671 if (!SWIG_IsOK(res1)) {
10672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10673 }
10674 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10675 {
10676 arg2 = wxString_in_helper(obj1);
10677 if (arg2 == NULL) SWIG_fail;
10678 temp2 = true;
10679 }
10680 if (obj2) {
10681 ecode3 = SWIG_AsVal_int(obj2, &val3);
10682 if (!SWIG_IsOK(ecode3)) {
10683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10684 }
10685 arg3 = static_cast< int >(val3);
10686 }
10687 {
10688 PyThreadState* __tstate = wxPyBeginAllowThreads();
10689 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10690 wxPyEndAllowThreads(__tstate);
10691 if (PyErr_Occurred()) SWIG_fail;
10692 }
10693 {
10694 #if wxUSE_UNICODE
10695 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10696 #else
10697 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10698 #endif
10699 }
10700 {
10701 if (temp2)
10702 delete arg2;
10703 }
10704 return resultobj;
10705 fail:
10706 {
10707 if (temp2)
10708 delete arg2;
10709 }
10710 return NULL;
10711 }
10712
10713
10714 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10715 PyObject *resultobj = 0;
10716 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10717 wxString result;
10718 void *argp1 = 0 ;
10719 int res1 = 0 ;
10720 PyObject *swig_obj[1] ;
10721
10722 if (!args) SWIG_fail;
10723 swig_obj[0] = args;
10724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10725 if (!SWIG_IsOK(res1)) {
10726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10727 }
10728 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10729 {
10730 PyThreadState* __tstate = wxPyBeginAllowThreads();
10731 result = (arg1)->FindNext();
10732 wxPyEndAllowThreads(__tstate);
10733 if (PyErr_Occurred()) SWIG_fail;
10734 }
10735 {
10736 #if wxUSE_UNICODE
10737 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10738 #else
10739 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10740 #endif
10741 }
10742 return resultobj;
10743 fail:
10744 return NULL;
10745 }
10746
10747
10748 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10749 PyObject *resultobj = 0;
10750 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10751 int res1 = 0 ;
10752 PyObject * obj0 = 0 ;
10753 char * kwnames[] = {
10754 (char *) "handler", NULL
10755 };
10756
10757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10758 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10759 if (!SWIG_IsOK(res1)) {
10760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10761 }
10762 {
10763 PyThreadState* __tstate = wxPyBeginAllowThreads();
10764 wxFileSystem::AddHandler(arg1);
10765 wxPyEndAllowThreads(__tstate);
10766 if (PyErr_Occurred()) SWIG_fail;
10767 }
10768 resultobj = SWIG_Py_Void();
10769 return resultobj;
10770 fail:
10771 return NULL;
10772 }
10773
10774
10775 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10776 PyObject *resultobj = 0;
10777
10778 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10779 {
10780 PyThreadState* __tstate = wxPyBeginAllowThreads();
10781 wxFileSystem::CleanUpHandlers();
10782 wxPyEndAllowThreads(__tstate);
10783 if (PyErr_Occurred()) SWIG_fail;
10784 }
10785 resultobj = SWIG_Py_Void();
10786 return resultobj;
10787 fail:
10788 return NULL;
10789 }
10790
10791
10792 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10793 PyObject *resultobj = 0;
10794 wxString *arg1 = 0 ;
10795 wxString result;
10796 bool temp1 = false ;
10797 PyObject * obj0 = 0 ;
10798 char * kwnames[] = {
10799 (char *) "filename", NULL
10800 };
10801
10802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10803 {
10804 arg1 = wxString_in_helper(obj0);
10805 if (arg1 == NULL) SWIG_fail;
10806 temp1 = true;
10807 }
10808 {
10809 PyThreadState* __tstate = wxPyBeginAllowThreads();
10810 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10811 wxPyEndAllowThreads(__tstate);
10812 if (PyErr_Occurred()) SWIG_fail;
10813 }
10814 {
10815 #if wxUSE_UNICODE
10816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10817 #else
10818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10819 #endif
10820 }
10821 {
10822 if (temp1)
10823 delete arg1;
10824 }
10825 return resultobj;
10826 fail:
10827 {
10828 if (temp1)
10829 delete arg1;
10830 }
10831 return NULL;
10832 }
10833
10834
10835 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10836 PyObject *resultobj = 0;
10837 wxString *arg1 = 0 ;
10838 wxString result;
10839 bool temp1 = false ;
10840 PyObject * obj0 = 0 ;
10841 char * kwnames[] = {
10842 (char *) "url", NULL
10843 };
10844
10845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10846 {
10847 arg1 = wxString_in_helper(obj0);
10848 if (arg1 == NULL) SWIG_fail;
10849 temp1 = true;
10850 }
10851 {
10852 PyThreadState* __tstate = wxPyBeginAllowThreads();
10853 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10854 wxPyEndAllowThreads(__tstate);
10855 if (PyErr_Occurred()) SWIG_fail;
10856 }
10857 {
10858 #if wxUSE_UNICODE
10859 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10860 #else
10861 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10862 #endif
10863 }
10864 {
10865 if (temp1)
10866 delete arg1;
10867 }
10868 return resultobj;
10869 fail:
10870 {
10871 if (temp1)
10872 delete arg1;
10873 }
10874 return NULL;
10875 }
10876
10877
10878 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10879 PyObject *obj;
10880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10881 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10882 return SWIG_Py_Void();
10883 }
10884
10885 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10886 return SWIG_Python_InitShadowInstance(args);
10887 }
10888
10889 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10890 PyObject *resultobj = 0;
10891 wxInternetFSHandler *result = 0 ;
10892
10893 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10894 {
10895 PyThreadState* __tstate = wxPyBeginAllowThreads();
10896 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10897 wxPyEndAllowThreads(__tstate);
10898 if (PyErr_Occurred()) SWIG_fail;
10899 }
10900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10901 return resultobj;
10902 fail:
10903 return NULL;
10904 }
10905
10906
10907 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10908 PyObject *resultobj = 0;
10909 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10910 wxString *arg2 = 0 ;
10911 bool result;
10912 void *argp1 = 0 ;
10913 int res1 = 0 ;
10914 bool temp2 = false ;
10915 PyObject * obj0 = 0 ;
10916 PyObject * obj1 = 0 ;
10917 char * kwnames[] = {
10918 (char *) "self",(char *) "location", NULL
10919 };
10920
10921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10923 if (!SWIG_IsOK(res1)) {
10924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10925 }
10926 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10927 {
10928 arg2 = wxString_in_helper(obj1);
10929 if (arg2 == NULL) SWIG_fail;
10930 temp2 = true;
10931 }
10932 {
10933 PyThreadState* __tstate = wxPyBeginAllowThreads();
10934 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10935 wxPyEndAllowThreads(__tstate);
10936 if (PyErr_Occurred()) SWIG_fail;
10937 }
10938 {
10939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10940 }
10941 {
10942 if (temp2)
10943 delete arg2;
10944 }
10945 return resultobj;
10946 fail:
10947 {
10948 if (temp2)
10949 delete arg2;
10950 }
10951 return NULL;
10952 }
10953
10954
10955 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10956 PyObject *resultobj = 0;
10957 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10958 wxFileSystem *arg2 = 0 ;
10959 wxString *arg3 = 0 ;
10960 wxFSFile *result = 0 ;
10961 void *argp1 = 0 ;
10962 int res1 = 0 ;
10963 void *argp2 = 0 ;
10964 int res2 = 0 ;
10965 bool temp3 = false ;
10966 PyObject * obj0 = 0 ;
10967 PyObject * obj1 = 0 ;
10968 PyObject * obj2 = 0 ;
10969 char * kwnames[] = {
10970 (char *) "self",(char *) "fs",(char *) "location", NULL
10971 };
10972
10973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10975 if (!SWIG_IsOK(res1)) {
10976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10977 }
10978 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10979 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10980 if (!SWIG_IsOK(res2)) {
10981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10982 }
10983 if (!argp2) {
10984 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10985 }
10986 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10987 {
10988 arg3 = wxString_in_helper(obj2);
10989 if (arg3 == NULL) SWIG_fail;
10990 temp3 = true;
10991 }
10992 {
10993 PyThreadState* __tstate = wxPyBeginAllowThreads();
10994 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10995 wxPyEndAllowThreads(__tstate);
10996 if (PyErr_Occurred()) SWIG_fail;
10997 }
10998 {
10999 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11000 }
11001 {
11002 if (temp3)
11003 delete arg3;
11004 }
11005 return resultobj;
11006 fail:
11007 {
11008 if (temp3)
11009 delete arg3;
11010 }
11011 return NULL;
11012 }
11013
11014
11015 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11016 PyObject *obj;
11017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11018 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11019 return SWIG_Py_Void();
11020 }
11021
11022 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11023 return SWIG_Python_InitShadowInstance(args);
11024 }
11025
11026 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11027 PyObject *resultobj = 0;
11028 wxZipFSHandler *result = 0 ;
11029
11030 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11031 {
11032 PyThreadState* __tstate = wxPyBeginAllowThreads();
11033 result = (wxZipFSHandler *)new wxZipFSHandler();
11034 wxPyEndAllowThreads(__tstate);
11035 if (PyErr_Occurred()) SWIG_fail;
11036 }
11037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11038 return resultobj;
11039 fail:
11040 return NULL;
11041 }
11042
11043
11044 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11045 PyObject *resultobj = 0;
11046 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11047 wxString *arg2 = 0 ;
11048 bool result;
11049 void *argp1 = 0 ;
11050 int res1 = 0 ;
11051 bool temp2 = false ;
11052 PyObject * obj0 = 0 ;
11053 PyObject * obj1 = 0 ;
11054 char * kwnames[] = {
11055 (char *) "self",(char *) "location", NULL
11056 };
11057
11058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11060 if (!SWIG_IsOK(res1)) {
11061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11062 }
11063 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11064 {
11065 arg2 = wxString_in_helper(obj1);
11066 if (arg2 == NULL) SWIG_fail;
11067 temp2 = true;
11068 }
11069 {
11070 PyThreadState* __tstate = wxPyBeginAllowThreads();
11071 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11072 wxPyEndAllowThreads(__tstate);
11073 if (PyErr_Occurred()) SWIG_fail;
11074 }
11075 {
11076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11077 }
11078 {
11079 if (temp2)
11080 delete arg2;
11081 }
11082 return resultobj;
11083 fail:
11084 {
11085 if (temp2)
11086 delete arg2;
11087 }
11088 return NULL;
11089 }
11090
11091
11092 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11093 PyObject *resultobj = 0;
11094 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11095 wxFileSystem *arg2 = 0 ;
11096 wxString *arg3 = 0 ;
11097 wxFSFile *result = 0 ;
11098 void *argp1 = 0 ;
11099 int res1 = 0 ;
11100 void *argp2 = 0 ;
11101 int res2 = 0 ;
11102 bool temp3 = false ;
11103 PyObject * obj0 = 0 ;
11104 PyObject * obj1 = 0 ;
11105 PyObject * obj2 = 0 ;
11106 char * kwnames[] = {
11107 (char *) "self",(char *) "fs",(char *) "location", NULL
11108 };
11109
11110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11112 if (!SWIG_IsOK(res1)) {
11113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11114 }
11115 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11116 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11117 if (!SWIG_IsOK(res2)) {
11118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11119 }
11120 if (!argp2) {
11121 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11122 }
11123 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11124 {
11125 arg3 = wxString_in_helper(obj2);
11126 if (arg3 == NULL) SWIG_fail;
11127 temp3 = true;
11128 }
11129 {
11130 PyThreadState* __tstate = wxPyBeginAllowThreads();
11131 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11132 wxPyEndAllowThreads(__tstate);
11133 if (PyErr_Occurred()) SWIG_fail;
11134 }
11135 {
11136 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11137 }
11138 {
11139 if (temp3)
11140 delete arg3;
11141 }
11142 return resultobj;
11143 fail:
11144 {
11145 if (temp3)
11146 delete arg3;
11147 }
11148 return NULL;
11149 }
11150
11151
11152 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11153 PyObject *resultobj = 0;
11154 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11155 wxString *arg2 = 0 ;
11156 int arg3 = (int) 0 ;
11157 wxString result;
11158 void *argp1 = 0 ;
11159 int res1 = 0 ;
11160 bool temp2 = false ;
11161 int val3 ;
11162 int ecode3 = 0 ;
11163 PyObject * obj0 = 0 ;
11164 PyObject * obj1 = 0 ;
11165 PyObject * obj2 = 0 ;
11166 char * kwnames[] = {
11167 (char *) "self",(char *) "spec",(char *) "flags", NULL
11168 };
11169
11170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11172 if (!SWIG_IsOK(res1)) {
11173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11174 }
11175 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11176 {
11177 arg2 = wxString_in_helper(obj1);
11178 if (arg2 == NULL) SWIG_fail;
11179 temp2 = true;
11180 }
11181 if (obj2) {
11182 ecode3 = SWIG_AsVal_int(obj2, &val3);
11183 if (!SWIG_IsOK(ecode3)) {
11184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11185 }
11186 arg3 = static_cast< int >(val3);
11187 }
11188 {
11189 PyThreadState* __tstate = wxPyBeginAllowThreads();
11190 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11191 wxPyEndAllowThreads(__tstate);
11192 if (PyErr_Occurred()) SWIG_fail;
11193 }
11194 {
11195 #if wxUSE_UNICODE
11196 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11197 #else
11198 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11199 #endif
11200 }
11201 {
11202 if (temp2)
11203 delete arg2;
11204 }
11205 return resultobj;
11206 fail:
11207 {
11208 if (temp2)
11209 delete arg2;
11210 }
11211 return NULL;
11212 }
11213
11214
11215 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11216 PyObject *resultobj = 0;
11217 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11218 wxString result;
11219 void *argp1 = 0 ;
11220 int res1 = 0 ;
11221 PyObject *swig_obj[1] ;
11222
11223 if (!args) SWIG_fail;
11224 swig_obj[0] = args;
11225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11226 if (!SWIG_IsOK(res1)) {
11227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11228 }
11229 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11230 {
11231 PyThreadState* __tstate = wxPyBeginAllowThreads();
11232 result = (arg1)->FindNext();
11233 wxPyEndAllowThreads(__tstate);
11234 if (PyErr_Occurred()) SWIG_fail;
11235 }
11236 {
11237 #if wxUSE_UNICODE
11238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11239 #else
11240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11241 #endif
11242 }
11243 return resultobj;
11244 fail:
11245 return NULL;
11246 }
11247
11248
11249 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11250 PyObject *obj;
11251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11252 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11253 return SWIG_Py_Void();
11254 }
11255
11256 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11257 return SWIG_Python_InitShadowInstance(args);
11258 }
11259
11260 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11261 PyObject *resultobj = 0;
11262 wxString *arg1 = 0 ;
11263 wxImage *arg2 = 0 ;
11264 long arg3 ;
11265 bool temp1 = false ;
11266 void *argp2 = 0 ;
11267 int res2 = 0 ;
11268 long val3 ;
11269 int ecode3 = 0 ;
11270 PyObject * obj0 = 0 ;
11271 PyObject * obj1 = 0 ;
11272 PyObject * obj2 = 0 ;
11273 char * kwnames[] = {
11274 (char *) "filename",(char *) "image",(char *) "type", NULL
11275 };
11276
11277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11278 {
11279 arg1 = wxString_in_helper(obj0);
11280 if (arg1 == NULL) SWIG_fail;
11281 temp1 = true;
11282 }
11283 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11284 if (!SWIG_IsOK(res2)) {
11285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11286 }
11287 if (!argp2) {
11288 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11289 }
11290 arg2 = reinterpret_cast< wxImage * >(argp2);
11291 ecode3 = SWIG_AsVal_long(obj2, &val3);
11292 if (!SWIG_IsOK(ecode3)) {
11293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11294 }
11295 arg3 = static_cast< long >(val3);
11296 {
11297 PyThreadState* __tstate = wxPyBeginAllowThreads();
11298 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11299 wxPyEndAllowThreads(__tstate);
11300 if (PyErr_Occurred()) SWIG_fail;
11301 }
11302 resultobj = SWIG_Py_Void();
11303 {
11304 if (temp1)
11305 delete arg1;
11306 }
11307 return resultobj;
11308 fail:
11309 {
11310 if (temp1)
11311 delete arg1;
11312 }
11313 return NULL;
11314 }
11315
11316
11317 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11318 PyObject *resultobj = 0;
11319 wxString *arg1 = 0 ;
11320 wxBitmap *arg2 = 0 ;
11321 long arg3 ;
11322 bool temp1 = false ;
11323 void *argp2 = 0 ;
11324 int res2 = 0 ;
11325 long val3 ;
11326 int ecode3 = 0 ;
11327 PyObject * obj0 = 0 ;
11328 PyObject * obj1 = 0 ;
11329 PyObject * obj2 = 0 ;
11330 char * kwnames[] = {
11331 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11332 };
11333
11334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11335 {
11336 arg1 = wxString_in_helper(obj0);
11337 if (arg1 == NULL) SWIG_fail;
11338 temp1 = true;
11339 }
11340 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11341 if (!SWIG_IsOK(res2)) {
11342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11343 }
11344 if (!argp2) {
11345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11346 }
11347 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11348 ecode3 = SWIG_AsVal_long(obj2, &val3);
11349 if (!SWIG_IsOK(ecode3)) {
11350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11351 }
11352 arg3 = static_cast< long >(val3);
11353 {
11354 PyThreadState* __tstate = wxPyBeginAllowThreads();
11355 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11356 wxPyEndAllowThreads(__tstate);
11357 if (PyErr_Occurred()) SWIG_fail;
11358 }
11359 resultobj = SWIG_Py_Void();
11360 {
11361 if (temp1)
11362 delete arg1;
11363 }
11364 return resultobj;
11365 fail:
11366 {
11367 if (temp1)
11368 delete arg1;
11369 }
11370 return NULL;
11371 }
11372
11373
11374 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11375 PyObject *resultobj = 0;
11376 wxString *arg1 = 0 ;
11377 PyObject *arg2 = (PyObject *) 0 ;
11378 bool temp1 = false ;
11379 PyObject * obj0 = 0 ;
11380 PyObject * obj1 = 0 ;
11381 char * kwnames[] = {
11382 (char *) "filename",(char *) "data", NULL
11383 };
11384
11385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11386 {
11387 arg1 = wxString_in_helper(obj0);
11388 if (arg1 == NULL) SWIG_fail;
11389 temp1 = true;
11390 }
11391 arg2 = obj1;
11392 {
11393 PyThreadState* __tstate = wxPyBeginAllowThreads();
11394 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11395 wxPyEndAllowThreads(__tstate);
11396 if (PyErr_Occurred()) SWIG_fail;
11397 }
11398 resultobj = SWIG_Py_Void();
11399 {
11400 if (temp1)
11401 delete arg1;
11402 }
11403 return resultobj;
11404 fail:
11405 {
11406 if (temp1)
11407 delete arg1;
11408 }
11409 return NULL;
11410 }
11411
11412
11413 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11414 PyObject *resultobj = 0;
11415 wxMemoryFSHandler *result = 0 ;
11416
11417 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11418 {
11419 PyThreadState* __tstate = wxPyBeginAllowThreads();
11420 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11421 wxPyEndAllowThreads(__tstate);
11422 if (PyErr_Occurred()) SWIG_fail;
11423 }
11424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11425 return resultobj;
11426 fail:
11427 return NULL;
11428 }
11429
11430
11431 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11432 PyObject *resultobj = 0;
11433 wxString *arg1 = 0 ;
11434 bool temp1 = false ;
11435 PyObject * obj0 = 0 ;
11436 char * kwnames[] = {
11437 (char *) "filename", NULL
11438 };
11439
11440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11441 {
11442 arg1 = wxString_in_helper(obj0);
11443 if (arg1 == NULL) SWIG_fail;
11444 temp1 = true;
11445 }
11446 {
11447 PyThreadState* __tstate = wxPyBeginAllowThreads();
11448 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11449 wxPyEndAllowThreads(__tstate);
11450 if (PyErr_Occurred()) SWIG_fail;
11451 }
11452 resultobj = SWIG_Py_Void();
11453 {
11454 if (temp1)
11455 delete arg1;
11456 }
11457 return resultobj;
11458 fail:
11459 {
11460 if (temp1)
11461 delete arg1;
11462 }
11463 return NULL;
11464 }
11465
11466
11467 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11468 PyObject *resultobj = 0;
11469 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11470 wxString *arg2 = 0 ;
11471 bool result;
11472 void *argp1 = 0 ;
11473 int res1 = 0 ;
11474 bool temp2 = false ;
11475 PyObject * obj0 = 0 ;
11476 PyObject * obj1 = 0 ;
11477 char * kwnames[] = {
11478 (char *) "self",(char *) "location", NULL
11479 };
11480
11481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11483 if (!SWIG_IsOK(res1)) {
11484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11485 }
11486 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11487 {
11488 arg2 = wxString_in_helper(obj1);
11489 if (arg2 == NULL) SWIG_fail;
11490 temp2 = true;
11491 }
11492 {
11493 PyThreadState* __tstate = wxPyBeginAllowThreads();
11494 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11495 wxPyEndAllowThreads(__tstate);
11496 if (PyErr_Occurred()) SWIG_fail;
11497 }
11498 {
11499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11500 }
11501 {
11502 if (temp2)
11503 delete arg2;
11504 }
11505 return resultobj;
11506 fail:
11507 {
11508 if (temp2)
11509 delete arg2;
11510 }
11511 return NULL;
11512 }
11513
11514
11515 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11516 PyObject *resultobj = 0;
11517 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11518 wxFileSystem *arg2 = 0 ;
11519 wxString *arg3 = 0 ;
11520 wxFSFile *result = 0 ;
11521 void *argp1 = 0 ;
11522 int res1 = 0 ;
11523 void *argp2 = 0 ;
11524 int res2 = 0 ;
11525 bool temp3 = false ;
11526 PyObject * obj0 = 0 ;
11527 PyObject * obj1 = 0 ;
11528 PyObject * obj2 = 0 ;
11529 char * kwnames[] = {
11530 (char *) "self",(char *) "fs",(char *) "location", NULL
11531 };
11532
11533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11535 if (!SWIG_IsOK(res1)) {
11536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11537 }
11538 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11539 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11540 if (!SWIG_IsOK(res2)) {
11541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11542 }
11543 if (!argp2) {
11544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11545 }
11546 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11547 {
11548 arg3 = wxString_in_helper(obj2);
11549 if (arg3 == NULL) SWIG_fail;
11550 temp3 = true;
11551 }
11552 {
11553 PyThreadState* __tstate = wxPyBeginAllowThreads();
11554 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11555 wxPyEndAllowThreads(__tstate);
11556 if (PyErr_Occurred()) SWIG_fail;
11557 }
11558 {
11559 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11560 }
11561 {
11562 if (temp3)
11563 delete arg3;
11564 }
11565 return resultobj;
11566 fail:
11567 {
11568 if (temp3)
11569 delete arg3;
11570 }
11571 return NULL;
11572 }
11573
11574
11575 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11576 PyObject *resultobj = 0;
11577 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11578 wxString *arg2 = 0 ;
11579 int arg3 = (int) 0 ;
11580 wxString result;
11581 void *argp1 = 0 ;
11582 int res1 = 0 ;
11583 bool temp2 = false ;
11584 int val3 ;
11585 int ecode3 = 0 ;
11586 PyObject * obj0 = 0 ;
11587 PyObject * obj1 = 0 ;
11588 PyObject * obj2 = 0 ;
11589 char * kwnames[] = {
11590 (char *) "self",(char *) "spec",(char *) "flags", NULL
11591 };
11592
11593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11595 if (!SWIG_IsOK(res1)) {
11596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11597 }
11598 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11599 {
11600 arg2 = wxString_in_helper(obj1);
11601 if (arg2 == NULL) SWIG_fail;
11602 temp2 = true;
11603 }
11604 if (obj2) {
11605 ecode3 = SWIG_AsVal_int(obj2, &val3);
11606 if (!SWIG_IsOK(ecode3)) {
11607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11608 }
11609 arg3 = static_cast< int >(val3);
11610 }
11611 {
11612 PyThreadState* __tstate = wxPyBeginAllowThreads();
11613 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11614 wxPyEndAllowThreads(__tstate);
11615 if (PyErr_Occurred()) SWIG_fail;
11616 }
11617 {
11618 #if wxUSE_UNICODE
11619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11620 #else
11621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11622 #endif
11623 }
11624 {
11625 if (temp2)
11626 delete arg2;
11627 }
11628 return resultobj;
11629 fail:
11630 {
11631 if (temp2)
11632 delete arg2;
11633 }
11634 return NULL;
11635 }
11636
11637
11638 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11639 PyObject *resultobj = 0;
11640 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11641 wxString result;
11642 void *argp1 = 0 ;
11643 int res1 = 0 ;
11644 PyObject *swig_obj[1] ;
11645
11646 if (!args) SWIG_fail;
11647 swig_obj[0] = args;
11648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11651 }
11652 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (arg1)->FindNext();
11656 wxPyEndAllowThreads(__tstate);
11657 if (PyErr_Occurred()) SWIG_fail;
11658 }
11659 {
11660 #if wxUSE_UNICODE
11661 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11662 #else
11663 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11664 #endif
11665 }
11666 return resultobj;
11667 fail:
11668 return NULL;
11669 }
11670
11671
11672 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11673 PyObject *obj;
11674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11675 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11676 return SWIG_Py_Void();
11677 }
11678
11679 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11680 return SWIG_Python_InitShadowInstance(args);
11681 }
11682
11683 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11684 PyObject *resultobj = 0;
11685 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11686 wxString result;
11687 void *argp1 = 0 ;
11688 int res1 = 0 ;
11689 PyObject *swig_obj[1] ;
11690
11691 if (!args) SWIG_fail;
11692 swig_obj[0] = args;
11693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11694 if (!SWIG_IsOK(res1)) {
11695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11696 }
11697 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11698 {
11699 PyThreadState* __tstate = wxPyBeginAllowThreads();
11700 result = (arg1)->GetName();
11701 wxPyEndAllowThreads(__tstate);
11702 if (PyErr_Occurred()) SWIG_fail;
11703 }
11704 {
11705 #if wxUSE_UNICODE
11706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11707 #else
11708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11709 #endif
11710 }
11711 return resultobj;
11712 fail:
11713 return NULL;
11714 }
11715
11716
11717 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11718 PyObject *resultobj = 0;
11719 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11720 wxString result;
11721 void *argp1 = 0 ;
11722 int res1 = 0 ;
11723 PyObject *swig_obj[1] ;
11724
11725 if (!args) SWIG_fail;
11726 swig_obj[0] = args;
11727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11728 if (!SWIG_IsOK(res1)) {
11729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11730 }
11731 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11732 {
11733 PyThreadState* __tstate = wxPyBeginAllowThreads();
11734 result = (arg1)->GetExtension();
11735 wxPyEndAllowThreads(__tstate);
11736 if (PyErr_Occurred()) SWIG_fail;
11737 }
11738 {
11739 #if wxUSE_UNICODE
11740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11741 #else
11742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11743 #endif
11744 }
11745 return resultobj;
11746 fail:
11747 return NULL;
11748 }
11749
11750
11751 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11752 PyObject *resultobj = 0;
11753 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11754 long result;
11755 void *argp1 = 0 ;
11756 int res1 = 0 ;
11757 PyObject *swig_obj[1] ;
11758
11759 if (!args) SWIG_fail;
11760 swig_obj[0] = args;
11761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11762 if (!SWIG_IsOK(res1)) {
11763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11764 }
11765 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11766 {
11767 PyThreadState* __tstate = wxPyBeginAllowThreads();
11768 result = (long)(arg1)->GetType();
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 resultobj = SWIG_From_long(static_cast< long >(result));
11773 return resultobj;
11774 fail:
11775 return NULL;
11776 }
11777
11778
11779 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11780 PyObject *resultobj = 0;
11781 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11782 wxString result;
11783 void *argp1 = 0 ;
11784 int res1 = 0 ;
11785 PyObject *swig_obj[1] ;
11786
11787 if (!args) SWIG_fail;
11788 swig_obj[0] = args;
11789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11790 if (!SWIG_IsOK(res1)) {
11791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11792 }
11793 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11794 {
11795 PyThreadState* __tstate = wxPyBeginAllowThreads();
11796 result = (arg1)->GetMimeType();
11797 wxPyEndAllowThreads(__tstate);
11798 if (PyErr_Occurred()) SWIG_fail;
11799 }
11800 {
11801 #if wxUSE_UNICODE
11802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11803 #else
11804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11805 #endif
11806 }
11807 return resultobj;
11808 fail:
11809 return NULL;
11810 }
11811
11812
11813 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11814 PyObject *resultobj = 0;
11815 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11816 wxString *arg2 = 0 ;
11817 bool result;
11818 void *argp1 = 0 ;
11819 int res1 = 0 ;
11820 bool temp2 = false ;
11821 PyObject * obj0 = 0 ;
11822 PyObject * obj1 = 0 ;
11823 char * kwnames[] = {
11824 (char *) "self",(char *) "name", NULL
11825 };
11826
11827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11829 if (!SWIG_IsOK(res1)) {
11830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11831 }
11832 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11833 {
11834 arg2 = wxString_in_helper(obj1);
11835 if (arg2 == NULL) SWIG_fail;
11836 temp2 = true;
11837 }
11838 {
11839 PyThreadState* __tstate = wxPyBeginAllowThreads();
11840 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11841 wxPyEndAllowThreads(__tstate);
11842 if (PyErr_Occurred()) SWIG_fail;
11843 }
11844 {
11845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11846 }
11847 {
11848 if (temp2)
11849 delete arg2;
11850 }
11851 return resultobj;
11852 fail:
11853 {
11854 if (temp2)
11855 delete arg2;
11856 }
11857 return NULL;
11858 }
11859
11860
11861 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11862 PyObject *resultobj = 0;
11863 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11864 wxString *arg2 = 0 ;
11865 void *argp1 = 0 ;
11866 int res1 = 0 ;
11867 bool temp2 = false ;
11868 PyObject * obj0 = 0 ;
11869 PyObject * obj1 = 0 ;
11870 char * kwnames[] = {
11871 (char *) "self",(char *) "name", NULL
11872 };
11873
11874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11876 if (!SWIG_IsOK(res1)) {
11877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11878 }
11879 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11880 {
11881 arg2 = wxString_in_helper(obj1);
11882 if (arg2 == NULL) SWIG_fail;
11883 temp2 = true;
11884 }
11885 {
11886 PyThreadState* __tstate = wxPyBeginAllowThreads();
11887 (arg1)->SetName((wxString const &)*arg2);
11888 wxPyEndAllowThreads(__tstate);
11889 if (PyErr_Occurred()) SWIG_fail;
11890 }
11891 resultobj = SWIG_Py_Void();
11892 {
11893 if (temp2)
11894 delete arg2;
11895 }
11896 return resultobj;
11897 fail:
11898 {
11899 if (temp2)
11900 delete arg2;
11901 }
11902 return NULL;
11903 }
11904
11905
11906 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11907 PyObject *resultobj = 0;
11908 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11909 wxString *arg2 = 0 ;
11910 void *argp1 = 0 ;
11911 int res1 = 0 ;
11912 bool temp2 = false ;
11913 PyObject * obj0 = 0 ;
11914 PyObject * obj1 = 0 ;
11915 char * kwnames[] = {
11916 (char *) "self",(char *) "extension", NULL
11917 };
11918
11919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11921 if (!SWIG_IsOK(res1)) {
11922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11923 }
11924 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11925 {
11926 arg2 = wxString_in_helper(obj1);
11927 if (arg2 == NULL) SWIG_fail;
11928 temp2 = true;
11929 }
11930 {
11931 PyThreadState* __tstate = wxPyBeginAllowThreads();
11932 (arg1)->SetExtension((wxString const &)*arg2);
11933 wxPyEndAllowThreads(__tstate);
11934 if (PyErr_Occurred()) SWIG_fail;
11935 }
11936 resultobj = SWIG_Py_Void();
11937 {
11938 if (temp2)
11939 delete arg2;
11940 }
11941 return resultobj;
11942 fail:
11943 {
11944 if (temp2)
11945 delete arg2;
11946 }
11947 return NULL;
11948 }
11949
11950
11951 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11952 PyObject *resultobj = 0;
11953 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11954 long arg2 ;
11955 void *argp1 = 0 ;
11956 int res1 = 0 ;
11957 long val2 ;
11958 int ecode2 = 0 ;
11959 PyObject * obj0 = 0 ;
11960 PyObject * obj1 = 0 ;
11961 char * kwnames[] = {
11962 (char *) "self",(char *) "type", NULL
11963 };
11964
11965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11967 if (!SWIG_IsOK(res1)) {
11968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11969 }
11970 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11971 ecode2 = SWIG_AsVal_long(obj1, &val2);
11972 if (!SWIG_IsOK(ecode2)) {
11973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11974 }
11975 arg2 = static_cast< long >(val2);
11976 {
11977 PyThreadState* __tstate = wxPyBeginAllowThreads();
11978 (arg1)->SetType(arg2);
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 resultobj = SWIG_Py_Void();
11983 return resultobj;
11984 fail:
11985 return NULL;
11986 }
11987
11988
11989 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11990 PyObject *resultobj = 0;
11991 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11992 wxString *arg2 = 0 ;
11993 void *argp1 = 0 ;
11994 int res1 = 0 ;
11995 bool temp2 = false ;
11996 PyObject * obj0 = 0 ;
11997 PyObject * obj1 = 0 ;
11998 char * kwnames[] = {
11999 (char *) "self",(char *) "mimetype", NULL
12000 };
12001
12002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12004 if (!SWIG_IsOK(res1)) {
12005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12006 }
12007 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12008 {
12009 arg2 = wxString_in_helper(obj1);
12010 if (arg2 == NULL) SWIG_fail;
12011 temp2 = true;
12012 }
12013 {
12014 PyThreadState* __tstate = wxPyBeginAllowThreads();
12015 (arg1)->SetMimeType((wxString const &)*arg2);
12016 wxPyEndAllowThreads(__tstate);
12017 if (PyErr_Occurred()) SWIG_fail;
12018 }
12019 resultobj = SWIG_Py_Void();
12020 {
12021 if (temp2)
12022 delete arg2;
12023 }
12024 return resultobj;
12025 fail:
12026 {
12027 if (temp2)
12028 delete arg2;
12029 }
12030 return NULL;
12031 }
12032
12033
12034 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12035 PyObject *obj;
12036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12037 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12038 return SWIG_Py_Void();
12039 }
12040
12041 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12042 PyObject *resultobj = 0;
12043 wxPyImageHandler *result = 0 ;
12044
12045 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12046 {
12047 PyThreadState* __tstate = wxPyBeginAllowThreads();
12048 result = (wxPyImageHandler *)new wxPyImageHandler();
12049 wxPyEndAllowThreads(__tstate);
12050 if (PyErr_Occurred()) SWIG_fail;
12051 }
12052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12053 return resultobj;
12054 fail:
12055 return NULL;
12056 }
12057
12058
12059 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12060 PyObject *resultobj = 0;
12061 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12062 PyObject *arg2 = (PyObject *) 0 ;
12063 void *argp1 = 0 ;
12064 int res1 = 0 ;
12065 PyObject * obj0 = 0 ;
12066 PyObject * obj1 = 0 ;
12067 char * kwnames[] = {
12068 (char *) "self",(char *) "self", NULL
12069 };
12070
12071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12073 if (!SWIG_IsOK(res1)) {
12074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12075 }
12076 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12077 arg2 = obj1;
12078 {
12079 PyThreadState* __tstate = wxPyBeginAllowThreads();
12080 (arg1)->_SetSelf(arg2);
12081 wxPyEndAllowThreads(__tstate);
12082 if (PyErr_Occurred()) SWIG_fail;
12083 }
12084 resultobj = SWIG_Py_Void();
12085 return resultobj;
12086 fail:
12087 return NULL;
12088 }
12089
12090
12091 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12092 PyObject *obj;
12093 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12094 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12095 return SWIG_Py_Void();
12096 }
12097
12098 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12099 return SWIG_Python_InitShadowInstance(args);
12100 }
12101
12102 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12103 PyObject *resultobj = 0;
12104 wxImageHistogram *result = 0 ;
12105
12106 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12107 {
12108 PyThreadState* __tstate = wxPyBeginAllowThreads();
12109 result = (wxImageHistogram *)new wxImageHistogram();
12110 wxPyEndAllowThreads(__tstate);
12111 if (PyErr_Occurred()) SWIG_fail;
12112 }
12113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12114 return resultobj;
12115 fail:
12116 return NULL;
12117 }
12118
12119
12120 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12121 PyObject *resultobj = 0;
12122 byte arg1 ;
12123 byte arg2 ;
12124 byte arg3 ;
12125 unsigned long result;
12126 unsigned char val1 ;
12127 int ecode1 = 0 ;
12128 unsigned char val2 ;
12129 int ecode2 = 0 ;
12130 unsigned char val3 ;
12131 int ecode3 = 0 ;
12132 PyObject * obj0 = 0 ;
12133 PyObject * obj1 = 0 ;
12134 PyObject * obj2 = 0 ;
12135 char * kwnames[] = {
12136 (char *) "r",(char *) "g",(char *) "b", NULL
12137 };
12138
12139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12140 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12141 if (!SWIG_IsOK(ecode1)) {
12142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12143 }
12144 arg1 = static_cast< byte >(val1);
12145 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12146 if (!SWIG_IsOK(ecode2)) {
12147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12148 }
12149 arg2 = static_cast< byte >(val2);
12150 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12151 if (!SWIG_IsOK(ecode3)) {
12152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12153 }
12154 arg3 = static_cast< byte >(val3);
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12162 return resultobj;
12163 fail:
12164 return NULL;
12165 }
12166
12167
12168 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12169 PyObject *resultobj = 0;
12170 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12171 byte *arg2 = (byte *) 0 ;
12172 byte *arg3 = (byte *) 0 ;
12173 byte *arg4 = (byte *) 0 ;
12174 byte arg5 = (byte) 1 ;
12175 byte arg6 = (byte) 0 ;
12176 byte arg7 = (byte) 0 ;
12177 bool result;
12178 void *argp1 = 0 ;
12179 int res1 = 0 ;
12180 byte temp2 ;
12181 int res2 = SWIG_TMPOBJ ;
12182 byte temp3 ;
12183 int res3 = SWIG_TMPOBJ ;
12184 byte temp4 ;
12185 int res4 = SWIG_TMPOBJ ;
12186 unsigned char val5 ;
12187 int ecode5 = 0 ;
12188 unsigned char val6 ;
12189 int ecode6 = 0 ;
12190 unsigned char val7 ;
12191 int ecode7 = 0 ;
12192 PyObject * obj0 = 0 ;
12193 PyObject * obj1 = 0 ;
12194 PyObject * obj2 = 0 ;
12195 PyObject * obj3 = 0 ;
12196 char * kwnames[] = {
12197 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12198 };
12199
12200 arg2 = &temp2;
12201 arg3 = &temp3;
12202 arg4 = &temp4;
12203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12205 if (!SWIG_IsOK(res1)) {
12206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12207 }
12208 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12209 if (obj1) {
12210 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12211 if (!SWIG_IsOK(ecode5)) {
12212 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12213 }
12214 arg5 = static_cast< byte >(val5);
12215 }
12216 if (obj2) {
12217 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12218 if (!SWIG_IsOK(ecode6)) {
12219 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12220 }
12221 arg6 = static_cast< byte >(val6);
12222 }
12223 if (obj3) {
12224 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12225 if (!SWIG_IsOK(ecode7)) {
12226 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12227 }
12228 arg7 = static_cast< byte >(val7);
12229 }
12230 {
12231 PyThreadState* __tstate = wxPyBeginAllowThreads();
12232 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 {
12237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12238 }
12239 if (SWIG_IsTmpObj(res2)) {
12240 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12241 } else {
12242 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12243 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12244 }
12245 if (SWIG_IsTmpObj(res3)) {
12246 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12247 } else {
12248 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12250 }
12251 if (SWIG_IsTmpObj(res4)) {
12252 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12253 } else {
12254 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12255 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12256 }
12257 return resultobj;
12258 fail:
12259 return NULL;
12260 }
12261
12262
12263 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12264 PyObject *resultobj = 0;
12265 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12266 unsigned long arg2 ;
12267 unsigned long result;
12268 void *argp1 = 0 ;
12269 int res1 = 0 ;
12270 unsigned long val2 ;
12271 int ecode2 = 0 ;
12272 PyObject * obj0 = 0 ;
12273 PyObject * obj1 = 0 ;
12274 char * kwnames[] = {
12275 (char *) "self",(char *) "key", NULL
12276 };
12277
12278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12280 if (!SWIG_IsOK(res1)) {
12281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12282 }
12283 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12284 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12285 if (!SWIG_IsOK(ecode2)) {
12286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12287 }
12288 arg2 = static_cast< unsigned long >(val2);
12289 {
12290 PyThreadState* __tstate = wxPyBeginAllowThreads();
12291 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12292 wxPyEndAllowThreads(__tstate);
12293 if (PyErr_Occurred()) SWIG_fail;
12294 }
12295 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12296 return resultobj;
12297 fail:
12298 return NULL;
12299 }
12300
12301
12302 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12303 PyObject *resultobj = 0;
12304 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12305 byte arg2 ;
12306 byte arg3 ;
12307 byte arg4 ;
12308 unsigned long result;
12309 void *argp1 = 0 ;
12310 int res1 = 0 ;
12311 unsigned char val2 ;
12312 int ecode2 = 0 ;
12313 unsigned char val3 ;
12314 int ecode3 = 0 ;
12315 unsigned char val4 ;
12316 int ecode4 = 0 ;
12317 PyObject * obj0 = 0 ;
12318 PyObject * obj1 = 0 ;
12319 PyObject * obj2 = 0 ;
12320 PyObject * obj3 = 0 ;
12321 char * kwnames[] = {
12322 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12323 };
12324
12325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12327 if (!SWIG_IsOK(res1)) {
12328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12329 }
12330 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12331 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12332 if (!SWIG_IsOK(ecode2)) {
12333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12334 }
12335 arg2 = static_cast< byte >(val2);
12336 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12337 if (!SWIG_IsOK(ecode3)) {
12338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12339 }
12340 arg3 = static_cast< byte >(val3);
12341 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12342 if (!SWIG_IsOK(ecode4)) {
12343 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12344 }
12345 arg4 = static_cast< byte >(val4);
12346 {
12347 PyThreadState* __tstate = wxPyBeginAllowThreads();
12348 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12349 wxPyEndAllowThreads(__tstate);
12350 if (PyErr_Occurred()) SWIG_fail;
12351 }
12352 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12353 return resultobj;
12354 fail:
12355 return NULL;
12356 }
12357
12358
12359 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12360 PyObject *resultobj = 0;
12361 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12362 wxColour *arg2 = 0 ;
12363 unsigned long result;
12364 void *argp1 = 0 ;
12365 int res1 = 0 ;
12366 wxColour temp2 ;
12367 PyObject * obj0 = 0 ;
12368 PyObject * obj1 = 0 ;
12369 char * kwnames[] = {
12370 (char *) "self",(char *) "colour", NULL
12371 };
12372
12373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12375 if (!SWIG_IsOK(res1)) {
12376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12377 }
12378 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12379 {
12380 arg2 = &temp2;
12381 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12382 }
12383 {
12384 PyThreadState* __tstate = wxPyBeginAllowThreads();
12385 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12386 wxPyEndAllowThreads(__tstate);
12387 if (PyErr_Occurred()) SWIG_fail;
12388 }
12389 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12390 return resultobj;
12391 fail:
12392 return NULL;
12393 }
12394
12395
12396 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12397 PyObject *obj;
12398 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12399 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12400 return SWIG_Py_Void();
12401 }
12402
12403 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12404 return SWIG_Python_InitShadowInstance(args);
12405 }
12406
12407 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12408 PyObject *resultobj = 0;
12409 byte arg1 = (byte) 0 ;
12410 byte arg2 = (byte) 0 ;
12411 byte arg3 = (byte) 0 ;
12412 wxImage_RGBValue *result = 0 ;
12413 unsigned char val1 ;
12414 int ecode1 = 0 ;
12415 unsigned char val2 ;
12416 int ecode2 = 0 ;
12417 unsigned char val3 ;
12418 int ecode3 = 0 ;
12419 PyObject * obj0 = 0 ;
12420 PyObject * obj1 = 0 ;
12421 PyObject * obj2 = 0 ;
12422 char * kwnames[] = {
12423 (char *) "r",(char *) "g",(char *) "b", NULL
12424 };
12425
12426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12427 if (obj0) {
12428 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12429 if (!SWIG_IsOK(ecode1)) {
12430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12431 }
12432 arg1 = static_cast< byte >(val1);
12433 }
12434 if (obj1) {
12435 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12436 if (!SWIG_IsOK(ecode2)) {
12437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12438 }
12439 arg2 = static_cast< byte >(val2);
12440 }
12441 if (obj2) {
12442 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12443 if (!SWIG_IsOK(ecode3)) {
12444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12445 }
12446 arg3 = static_cast< byte >(val3);
12447 }
12448 {
12449 PyThreadState* __tstate = wxPyBeginAllowThreads();
12450 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12451 wxPyEndAllowThreads(__tstate);
12452 if (PyErr_Occurred()) SWIG_fail;
12453 }
12454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12455 return resultobj;
12456 fail:
12457 return NULL;
12458 }
12459
12460
12461 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12462 PyObject *resultobj = 0;
12463 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12464 byte arg2 ;
12465 void *argp1 = 0 ;
12466 int res1 = 0 ;
12467 unsigned char val2 ;
12468 int ecode2 = 0 ;
12469 PyObject *swig_obj[2] ;
12470
12471 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12473 if (!SWIG_IsOK(res1)) {
12474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12475 }
12476 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12477 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12478 if (!SWIG_IsOK(ecode2)) {
12479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12480 }
12481 arg2 = static_cast< byte >(val2);
12482 if (arg1) (arg1)->red = arg2;
12483
12484 resultobj = SWIG_Py_Void();
12485 return resultobj;
12486 fail:
12487 return NULL;
12488 }
12489
12490
12491 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12492 PyObject *resultobj = 0;
12493 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12494 byte result;
12495 void *argp1 = 0 ;
12496 int res1 = 0 ;
12497 PyObject *swig_obj[1] ;
12498
12499 if (!args) SWIG_fail;
12500 swig_obj[0] = args;
12501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12502 if (!SWIG_IsOK(res1)) {
12503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12504 }
12505 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12506 result = (byte) ((arg1)->red);
12507 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12508 return resultobj;
12509 fail:
12510 return NULL;
12511 }
12512
12513
12514 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12515 PyObject *resultobj = 0;
12516 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12517 byte arg2 ;
12518 void *argp1 = 0 ;
12519 int res1 = 0 ;
12520 unsigned char val2 ;
12521 int ecode2 = 0 ;
12522 PyObject *swig_obj[2] ;
12523
12524 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12526 if (!SWIG_IsOK(res1)) {
12527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12528 }
12529 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12530 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12531 if (!SWIG_IsOK(ecode2)) {
12532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12533 }
12534 arg2 = static_cast< byte >(val2);
12535 if (arg1) (arg1)->green = arg2;
12536
12537 resultobj = SWIG_Py_Void();
12538 return resultobj;
12539 fail:
12540 return NULL;
12541 }
12542
12543
12544 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12545 PyObject *resultobj = 0;
12546 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12547 byte result;
12548 void *argp1 = 0 ;
12549 int res1 = 0 ;
12550 PyObject *swig_obj[1] ;
12551
12552 if (!args) SWIG_fail;
12553 swig_obj[0] = args;
12554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12555 if (!SWIG_IsOK(res1)) {
12556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12557 }
12558 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12559 result = (byte) ((arg1)->green);
12560 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12561 return resultobj;
12562 fail:
12563 return NULL;
12564 }
12565
12566
12567 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12568 PyObject *resultobj = 0;
12569 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12570 byte arg2 ;
12571 void *argp1 = 0 ;
12572 int res1 = 0 ;
12573 unsigned char val2 ;
12574 int ecode2 = 0 ;
12575 PyObject *swig_obj[2] ;
12576
12577 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12579 if (!SWIG_IsOK(res1)) {
12580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12581 }
12582 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12583 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12584 if (!SWIG_IsOK(ecode2)) {
12585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12586 }
12587 arg2 = static_cast< byte >(val2);
12588 if (arg1) (arg1)->blue = arg2;
12589
12590 resultobj = SWIG_Py_Void();
12591 return resultobj;
12592 fail:
12593 return NULL;
12594 }
12595
12596
12597 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12598 PyObject *resultobj = 0;
12599 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12600 byte result;
12601 void *argp1 = 0 ;
12602 int res1 = 0 ;
12603 PyObject *swig_obj[1] ;
12604
12605 if (!args) SWIG_fail;
12606 swig_obj[0] = args;
12607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12608 if (!SWIG_IsOK(res1)) {
12609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12610 }
12611 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12612 result = (byte) ((arg1)->blue);
12613 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12614 return resultobj;
12615 fail:
12616 return NULL;
12617 }
12618
12619
12620 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12621 PyObject *obj;
12622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12623 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12624 return SWIG_Py_Void();
12625 }
12626
12627 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12628 return SWIG_Python_InitShadowInstance(args);
12629 }
12630
12631 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12632 PyObject *resultobj = 0;
12633 double arg1 = (double) 0.0 ;
12634 double arg2 = (double) 0.0 ;
12635 double arg3 = (double) 0.0 ;
12636 wxImage_HSVValue *result = 0 ;
12637 double val1 ;
12638 int ecode1 = 0 ;
12639 double val2 ;
12640 int ecode2 = 0 ;
12641 double val3 ;
12642 int ecode3 = 0 ;
12643 PyObject * obj0 = 0 ;
12644 PyObject * obj1 = 0 ;
12645 PyObject * obj2 = 0 ;
12646 char * kwnames[] = {
12647 (char *) "h",(char *) "s",(char *) "v", NULL
12648 };
12649
12650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12651 if (obj0) {
12652 ecode1 = SWIG_AsVal_double(obj0, &val1);
12653 if (!SWIG_IsOK(ecode1)) {
12654 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12655 }
12656 arg1 = static_cast< double >(val1);
12657 }
12658 if (obj1) {
12659 ecode2 = SWIG_AsVal_double(obj1, &val2);
12660 if (!SWIG_IsOK(ecode2)) {
12661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12662 }
12663 arg2 = static_cast< double >(val2);
12664 }
12665 if (obj2) {
12666 ecode3 = SWIG_AsVal_double(obj2, &val3);
12667 if (!SWIG_IsOK(ecode3)) {
12668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12669 }
12670 arg3 = static_cast< double >(val3);
12671 }
12672 {
12673 PyThreadState* __tstate = wxPyBeginAllowThreads();
12674 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12675 wxPyEndAllowThreads(__tstate);
12676 if (PyErr_Occurred()) SWIG_fail;
12677 }
12678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12679 return resultobj;
12680 fail:
12681 return NULL;
12682 }
12683
12684
12685 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12686 PyObject *resultobj = 0;
12687 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12688 double arg2 ;
12689 void *argp1 = 0 ;
12690 int res1 = 0 ;
12691 double val2 ;
12692 int ecode2 = 0 ;
12693 PyObject *swig_obj[2] ;
12694
12695 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12697 if (!SWIG_IsOK(res1)) {
12698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12699 }
12700 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12701 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12702 if (!SWIG_IsOK(ecode2)) {
12703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12704 }
12705 arg2 = static_cast< double >(val2);
12706 if (arg1) (arg1)->hue = arg2;
12707
12708 resultobj = SWIG_Py_Void();
12709 return resultobj;
12710 fail:
12711 return NULL;
12712 }
12713
12714
12715 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12716 PyObject *resultobj = 0;
12717 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12718 double result;
12719 void *argp1 = 0 ;
12720 int res1 = 0 ;
12721 PyObject *swig_obj[1] ;
12722
12723 if (!args) SWIG_fail;
12724 swig_obj[0] = args;
12725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12726 if (!SWIG_IsOK(res1)) {
12727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12728 }
12729 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12730 result = (double) ((arg1)->hue);
12731 resultobj = SWIG_From_double(static_cast< double >(result));
12732 return resultobj;
12733 fail:
12734 return NULL;
12735 }
12736
12737
12738 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12739 PyObject *resultobj = 0;
12740 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12741 double arg2 ;
12742 void *argp1 = 0 ;
12743 int res1 = 0 ;
12744 double val2 ;
12745 int ecode2 = 0 ;
12746 PyObject *swig_obj[2] ;
12747
12748 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12750 if (!SWIG_IsOK(res1)) {
12751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12752 }
12753 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12754 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12755 if (!SWIG_IsOK(ecode2)) {
12756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12757 }
12758 arg2 = static_cast< double >(val2);
12759 if (arg1) (arg1)->saturation = arg2;
12760
12761 resultobj = SWIG_Py_Void();
12762 return resultobj;
12763 fail:
12764 return NULL;
12765 }
12766
12767
12768 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12769 PyObject *resultobj = 0;
12770 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12771 double result;
12772 void *argp1 = 0 ;
12773 int res1 = 0 ;
12774 PyObject *swig_obj[1] ;
12775
12776 if (!args) SWIG_fail;
12777 swig_obj[0] = args;
12778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12779 if (!SWIG_IsOK(res1)) {
12780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12781 }
12782 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12783 result = (double) ((arg1)->saturation);
12784 resultobj = SWIG_From_double(static_cast< double >(result));
12785 return resultobj;
12786 fail:
12787 return NULL;
12788 }
12789
12790
12791 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12792 PyObject *resultobj = 0;
12793 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12794 double arg2 ;
12795 void *argp1 = 0 ;
12796 int res1 = 0 ;
12797 double val2 ;
12798 int ecode2 = 0 ;
12799 PyObject *swig_obj[2] ;
12800
12801 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12803 if (!SWIG_IsOK(res1)) {
12804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12805 }
12806 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12807 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12808 if (!SWIG_IsOK(ecode2)) {
12809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12810 }
12811 arg2 = static_cast< double >(val2);
12812 if (arg1) (arg1)->value = arg2;
12813
12814 resultobj = SWIG_Py_Void();
12815 return resultobj;
12816 fail:
12817 return NULL;
12818 }
12819
12820
12821 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12822 PyObject *resultobj = 0;
12823 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12824 double result;
12825 void *argp1 = 0 ;
12826 int res1 = 0 ;
12827 PyObject *swig_obj[1] ;
12828
12829 if (!args) SWIG_fail;
12830 swig_obj[0] = args;
12831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12832 if (!SWIG_IsOK(res1)) {
12833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12834 }
12835 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12836 result = (double) ((arg1)->value);
12837 resultobj = SWIG_From_double(static_cast< double >(result));
12838 return resultobj;
12839 fail:
12840 return NULL;
12841 }
12842
12843
12844 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12845 PyObject *obj;
12846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12847 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12848 return SWIG_Py_Void();
12849 }
12850
12851 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12852 return SWIG_Python_InitShadowInstance(args);
12853 }
12854
12855 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12856 PyObject *resultobj = 0;
12857 wxString *arg1 = 0 ;
12858 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12859 int arg3 = (int) -1 ;
12860 wxImage *result = 0 ;
12861 bool temp1 = false ;
12862 long val2 ;
12863 int ecode2 = 0 ;
12864 int val3 ;
12865 int ecode3 = 0 ;
12866 PyObject * obj0 = 0 ;
12867 PyObject * obj1 = 0 ;
12868 PyObject * obj2 = 0 ;
12869 char * kwnames[] = {
12870 (char *) "name",(char *) "type",(char *) "index", NULL
12871 };
12872
12873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12874 {
12875 arg1 = wxString_in_helper(obj0);
12876 if (arg1 == NULL) SWIG_fail;
12877 temp1 = true;
12878 }
12879 if (obj1) {
12880 ecode2 = SWIG_AsVal_long(obj1, &val2);
12881 if (!SWIG_IsOK(ecode2)) {
12882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12883 }
12884 arg2 = static_cast< long >(val2);
12885 }
12886 if (obj2) {
12887 ecode3 = SWIG_AsVal_int(obj2, &val3);
12888 if (!SWIG_IsOK(ecode3)) {
12889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12890 }
12891 arg3 = static_cast< int >(val3);
12892 }
12893 {
12894 PyThreadState* __tstate = wxPyBeginAllowThreads();
12895 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12896 wxPyEndAllowThreads(__tstate);
12897 if (PyErr_Occurred()) SWIG_fail;
12898 }
12899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12900 {
12901 if (temp1)
12902 delete arg1;
12903 }
12904 return resultobj;
12905 fail:
12906 {
12907 if (temp1)
12908 delete arg1;
12909 }
12910 return NULL;
12911 }
12912
12913
12914 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12915 PyObject *resultobj = 0;
12916 wxImage *arg1 = (wxImage *) 0 ;
12917 void *argp1 = 0 ;
12918 int res1 = 0 ;
12919 PyObject *swig_obj[1] ;
12920
12921 if (!args) SWIG_fail;
12922 swig_obj[0] = args;
12923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12924 if (!SWIG_IsOK(res1)) {
12925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12926 }
12927 arg1 = reinterpret_cast< wxImage * >(argp1);
12928 {
12929 PyThreadState* __tstate = wxPyBeginAllowThreads();
12930 delete arg1;
12931
12932 wxPyEndAllowThreads(__tstate);
12933 if (PyErr_Occurred()) SWIG_fail;
12934 }
12935 resultobj = SWIG_Py_Void();
12936 return resultobj;
12937 fail:
12938 return NULL;
12939 }
12940
12941
12942 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12943 PyObject *resultobj = 0;
12944 wxString *arg1 = 0 ;
12945 wxString *arg2 = 0 ;
12946 int arg3 = (int) -1 ;
12947 wxImage *result = 0 ;
12948 bool temp1 = false ;
12949 bool temp2 = false ;
12950 int val3 ;
12951 int ecode3 = 0 ;
12952 PyObject * obj0 = 0 ;
12953 PyObject * obj1 = 0 ;
12954 PyObject * obj2 = 0 ;
12955 char * kwnames[] = {
12956 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12957 };
12958
12959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12960 {
12961 arg1 = wxString_in_helper(obj0);
12962 if (arg1 == NULL) SWIG_fail;
12963 temp1 = true;
12964 }
12965 {
12966 arg2 = wxString_in_helper(obj1);
12967 if (arg2 == NULL) SWIG_fail;
12968 temp2 = true;
12969 }
12970 if (obj2) {
12971 ecode3 = SWIG_AsVal_int(obj2, &val3);
12972 if (!SWIG_IsOK(ecode3)) {
12973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12974 }
12975 arg3 = static_cast< int >(val3);
12976 }
12977 {
12978 PyThreadState* __tstate = wxPyBeginAllowThreads();
12979 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12980 wxPyEndAllowThreads(__tstate);
12981 if (PyErr_Occurred()) SWIG_fail;
12982 }
12983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12984 {
12985 if (temp1)
12986 delete arg1;
12987 }
12988 {
12989 if (temp2)
12990 delete arg2;
12991 }
12992 return resultobj;
12993 fail:
12994 {
12995 if (temp1)
12996 delete arg1;
12997 }
12998 {
12999 if (temp2)
13000 delete arg2;
13001 }
13002 return NULL;
13003 }
13004
13005
13006 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13007 PyObject *resultobj = 0;
13008 wxInputStream *arg1 = 0 ;
13009 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13010 int arg3 = (int) -1 ;
13011 wxImage *result = 0 ;
13012 wxPyInputStream *temp1 ;
13013 bool created1 ;
13014 long val2 ;
13015 int ecode2 = 0 ;
13016 int val3 ;
13017 int ecode3 = 0 ;
13018 PyObject * obj0 = 0 ;
13019 PyObject * obj1 = 0 ;
13020 PyObject * obj2 = 0 ;
13021 char * kwnames[] = {
13022 (char *) "stream",(char *) "type",(char *) "index", NULL
13023 };
13024
13025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13026 {
13027 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13028 arg1 = temp1->m_wxis;
13029 created1 = false;
13030 } else {
13031 PyErr_Clear(); // clear the failure of the wxPyConvert above
13032 arg1 = wxPyCBInputStream_create(obj0, false);
13033 if (arg1 == NULL) {
13034 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13035 SWIG_fail;
13036 }
13037 created1 = true;
13038 }
13039 }
13040 if (obj1) {
13041 ecode2 = SWIG_AsVal_long(obj1, &val2);
13042 if (!SWIG_IsOK(ecode2)) {
13043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13044 }
13045 arg2 = static_cast< long >(val2);
13046 }
13047 if (obj2) {
13048 ecode3 = SWIG_AsVal_int(obj2, &val3);
13049 if (!SWIG_IsOK(ecode3)) {
13050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13051 }
13052 arg3 = static_cast< int >(val3);
13053 }
13054 {
13055 PyThreadState* __tstate = wxPyBeginAllowThreads();
13056 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13057 wxPyEndAllowThreads(__tstate);
13058 if (PyErr_Occurred()) SWIG_fail;
13059 }
13060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13061 {
13062 if (created1) delete arg1;
13063 }
13064 return resultobj;
13065 fail:
13066 {
13067 if (created1) delete arg1;
13068 }
13069 return NULL;
13070 }
13071
13072
13073 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13074 PyObject *resultobj = 0;
13075 wxInputStream *arg1 = 0 ;
13076 wxString *arg2 = 0 ;
13077 int arg3 = (int) -1 ;
13078 wxImage *result = 0 ;
13079 wxPyInputStream *temp1 ;
13080 bool created1 ;
13081 bool temp2 = false ;
13082 int val3 ;
13083 int ecode3 = 0 ;
13084 PyObject * obj0 = 0 ;
13085 PyObject * obj1 = 0 ;
13086 PyObject * obj2 = 0 ;
13087 char * kwnames[] = {
13088 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13089 };
13090
13091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13092 {
13093 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13094 arg1 = temp1->m_wxis;
13095 created1 = false;
13096 } else {
13097 PyErr_Clear(); // clear the failure of the wxPyConvert above
13098 arg1 = wxPyCBInputStream_create(obj0, false);
13099 if (arg1 == NULL) {
13100 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13101 SWIG_fail;
13102 }
13103 created1 = true;
13104 }
13105 }
13106 {
13107 arg2 = wxString_in_helper(obj1);
13108 if (arg2 == NULL) SWIG_fail;
13109 temp2 = true;
13110 }
13111 if (obj2) {
13112 ecode3 = SWIG_AsVal_int(obj2, &val3);
13113 if (!SWIG_IsOK(ecode3)) {
13114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13115 }
13116 arg3 = static_cast< int >(val3);
13117 }
13118 {
13119 PyThreadState* __tstate = wxPyBeginAllowThreads();
13120 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13121 wxPyEndAllowThreads(__tstate);
13122 if (PyErr_Occurred()) SWIG_fail;
13123 }
13124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13125 {
13126 if (created1) delete arg1;
13127 }
13128 {
13129 if (temp2)
13130 delete arg2;
13131 }
13132 return resultobj;
13133 fail:
13134 {
13135 if (created1) delete arg1;
13136 }
13137 {
13138 if (temp2)
13139 delete arg2;
13140 }
13141 return NULL;
13142 }
13143
13144
13145 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13146 PyObject *resultobj = 0;
13147 int arg1 = (int) 0 ;
13148 int arg2 = (int) 0 ;
13149 bool arg3 = (bool) true ;
13150 wxImage *result = 0 ;
13151 int val1 ;
13152 int ecode1 = 0 ;
13153 int val2 ;
13154 int ecode2 = 0 ;
13155 bool val3 ;
13156 int ecode3 = 0 ;
13157 PyObject * obj0 = 0 ;
13158 PyObject * obj1 = 0 ;
13159 PyObject * obj2 = 0 ;
13160 char * kwnames[] = {
13161 (char *) "width",(char *) "height",(char *) "clear", NULL
13162 };
13163
13164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13165 if (obj0) {
13166 ecode1 = SWIG_AsVal_int(obj0, &val1);
13167 if (!SWIG_IsOK(ecode1)) {
13168 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13169 }
13170 arg1 = static_cast< int >(val1);
13171 }
13172 if (obj1) {
13173 ecode2 = SWIG_AsVal_int(obj1, &val2);
13174 if (!SWIG_IsOK(ecode2)) {
13175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13176 }
13177 arg2 = static_cast< int >(val2);
13178 }
13179 if (obj2) {
13180 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13181 if (!SWIG_IsOK(ecode3)) {
13182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13183 }
13184 arg3 = static_cast< bool >(val3);
13185 }
13186 {
13187 PyThreadState* __tstate = wxPyBeginAllowThreads();
13188 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13189 wxPyEndAllowThreads(__tstate);
13190 if (PyErr_Occurred()) SWIG_fail;
13191 }
13192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13193 return resultobj;
13194 fail:
13195 return NULL;
13196 }
13197
13198
13199 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13200 PyObject *resultobj = 0;
13201 wxBitmap *arg1 = 0 ;
13202 wxImage *result = 0 ;
13203 void *argp1 = 0 ;
13204 int res1 = 0 ;
13205 PyObject * obj0 = 0 ;
13206 char * kwnames[] = {
13207 (char *) "bitmap", NULL
13208 };
13209
13210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13211 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13212 if (!SWIG_IsOK(res1)) {
13213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13214 }
13215 if (!argp1) {
13216 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13217 }
13218 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13219 {
13220 if (!wxPyCheckForApp()) SWIG_fail;
13221 PyThreadState* __tstate = wxPyBeginAllowThreads();
13222 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13223 wxPyEndAllowThreads(__tstate);
13224 if (PyErr_Occurred()) SWIG_fail;
13225 }
13226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13227 return resultobj;
13228 fail:
13229 return NULL;
13230 }
13231
13232
13233 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13234 PyObject *resultobj = 0;
13235 int arg1 ;
13236 int arg2 ;
13237 buffer arg3 ;
13238 int arg4 ;
13239 wxImage *result = 0 ;
13240 int val1 ;
13241 int ecode1 = 0 ;
13242 int val2 ;
13243 int ecode2 = 0 ;
13244 PyObject * obj0 = 0 ;
13245 PyObject * obj1 = 0 ;
13246 PyObject * obj2 = 0 ;
13247 char * kwnames[] = {
13248 (char *) "width",(char *) "height",(char *) "data", NULL
13249 };
13250
13251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13252 ecode1 = SWIG_AsVal_int(obj0, &val1);
13253 if (!SWIG_IsOK(ecode1)) {
13254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13255 }
13256 arg1 = static_cast< int >(val1);
13257 ecode2 = SWIG_AsVal_int(obj1, &val2);
13258 if (!SWIG_IsOK(ecode2)) {
13259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13260 }
13261 arg2 = static_cast< int >(val2);
13262 {
13263 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13264 }
13265 {
13266 PyThreadState* __tstate = wxPyBeginAllowThreads();
13267 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13268 wxPyEndAllowThreads(__tstate);
13269 if (PyErr_Occurred()) SWIG_fail;
13270 }
13271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13272 return resultobj;
13273 fail:
13274 return NULL;
13275 }
13276
13277
13278 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13279 PyObject *resultobj = 0;
13280 int arg1 ;
13281 int arg2 ;
13282 buffer arg3 ;
13283 int arg4 ;
13284 buffer arg5 ;
13285 int arg6 ;
13286 wxImage *result = 0 ;
13287 int val1 ;
13288 int ecode1 = 0 ;
13289 int val2 ;
13290 int ecode2 = 0 ;
13291 PyObject * obj0 = 0 ;
13292 PyObject * obj1 = 0 ;
13293 PyObject * obj2 = 0 ;
13294 PyObject * obj3 = 0 ;
13295 char * kwnames[] = {
13296 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13297 };
13298
13299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13300 ecode1 = SWIG_AsVal_int(obj0, &val1);
13301 if (!SWIG_IsOK(ecode1)) {
13302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13303 }
13304 arg1 = static_cast< int >(val1);
13305 ecode2 = SWIG_AsVal_int(obj1, &val2);
13306 if (!SWIG_IsOK(ecode2)) {
13307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13308 }
13309 arg2 = static_cast< int >(val2);
13310 {
13311 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13312 }
13313 {
13314 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13315 }
13316 {
13317 PyThreadState* __tstate = wxPyBeginAllowThreads();
13318 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13323 return resultobj;
13324 fail:
13325 return NULL;
13326 }
13327
13328
13329 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13330 PyObject *resultobj = 0;
13331 wxImage *arg1 = (wxImage *) 0 ;
13332 int arg2 ;
13333 int arg3 ;
13334 bool arg4 = (bool) true ;
13335 void *argp1 = 0 ;
13336 int res1 = 0 ;
13337 int val2 ;
13338 int ecode2 = 0 ;
13339 int val3 ;
13340 int ecode3 = 0 ;
13341 bool val4 ;
13342 int ecode4 = 0 ;
13343 PyObject * obj0 = 0 ;
13344 PyObject * obj1 = 0 ;
13345 PyObject * obj2 = 0 ;
13346 PyObject * obj3 = 0 ;
13347 char * kwnames[] = {
13348 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13349 };
13350
13351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13353 if (!SWIG_IsOK(res1)) {
13354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13355 }
13356 arg1 = reinterpret_cast< wxImage * >(argp1);
13357 ecode2 = SWIG_AsVal_int(obj1, &val2);
13358 if (!SWIG_IsOK(ecode2)) {
13359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13360 }
13361 arg2 = static_cast< int >(val2);
13362 ecode3 = SWIG_AsVal_int(obj2, &val3);
13363 if (!SWIG_IsOK(ecode3)) {
13364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13365 }
13366 arg3 = static_cast< int >(val3);
13367 if (obj3) {
13368 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13369 if (!SWIG_IsOK(ecode4)) {
13370 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13371 }
13372 arg4 = static_cast< bool >(val4);
13373 }
13374 {
13375 PyThreadState* __tstate = wxPyBeginAllowThreads();
13376 (arg1)->Create(arg2,arg3,arg4);
13377 wxPyEndAllowThreads(__tstate);
13378 if (PyErr_Occurred()) SWIG_fail;
13379 }
13380 resultobj = SWIG_Py_Void();
13381 return resultobj;
13382 fail:
13383 return NULL;
13384 }
13385
13386
13387 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13388 PyObject *resultobj = 0;
13389 wxImage *arg1 = (wxImage *) 0 ;
13390 void *argp1 = 0 ;
13391 int res1 = 0 ;
13392 PyObject *swig_obj[1] ;
13393
13394 if (!args) SWIG_fail;
13395 swig_obj[0] = args;
13396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13397 if (!SWIG_IsOK(res1)) {
13398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13399 }
13400 arg1 = reinterpret_cast< wxImage * >(argp1);
13401 {
13402 PyThreadState* __tstate = wxPyBeginAllowThreads();
13403 (arg1)->Destroy();
13404 wxPyEndAllowThreads(__tstate);
13405 if (PyErr_Occurred()) SWIG_fail;
13406 }
13407 resultobj = SWIG_Py_Void();
13408 return resultobj;
13409 fail:
13410 return NULL;
13411 }
13412
13413
13414 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13415 PyObject *resultobj = 0;
13416 wxImage *arg1 = (wxImage *) 0 ;
13417 int arg2 ;
13418 int arg3 ;
13419 SwigValueWrapper<wxImage > result;
13420 void *argp1 = 0 ;
13421 int res1 = 0 ;
13422 int val2 ;
13423 int ecode2 = 0 ;
13424 int val3 ;
13425 int ecode3 = 0 ;
13426 PyObject * obj0 = 0 ;
13427 PyObject * obj1 = 0 ;
13428 PyObject * obj2 = 0 ;
13429 char * kwnames[] = {
13430 (char *) "self",(char *) "width",(char *) "height", NULL
13431 };
13432
13433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13435 if (!SWIG_IsOK(res1)) {
13436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13437 }
13438 arg1 = reinterpret_cast< wxImage * >(argp1);
13439 ecode2 = SWIG_AsVal_int(obj1, &val2);
13440 if (!SWIG_IsOK(ecode2)) {
13441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13442 }
13443 arg2 = static_cast< int >(val2);
13444 ecode3 = SWIG_AsVal_int(obj2, &val3);
13445 if (!SWIG_IsOK(ecode3)) {
13446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13447 }
13448 arg3 = static_cast< int >(val3);
13449 {
13450 PyThreadState* __tstate = wxPyBeginAllowThreads();
13451 result = (arg1)->Scale(arg2,arg3);
13452 wxPyEndAllowThreads(__tstate);
13453 if (PyErr_Occurred()) SWIG_fail;
13454 }
13455 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13456 return resultobj;
13457 fail:
13458 return NULL;
13459 }
13460
13461
13462 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13463 PyObject *resultobj = 0;
13464 wxImage *arg1 = (wxImage *) 0 ;
13465 int arg2 ;
13466 int arg3 ;
13467 SwigValueWrapper<wxImage > result;
13468 void *argp1 = 0 ;
13469 int res1 = 0 ;
13470 int val2 ;
13471 int ecode2 = 0 ;
13472 int val3 ;
13473 int ecode3 = 0 ;
13474 PyObject * obj0 = 0 ;
13475 PyObject * obj1 = 0 ;
13476 PyObject * obj2 = 0 ;
13477 char * kwnames[] = {
13478 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13479 };
13480
13481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13483 if (!SWIG_IsOK(res1)) {
13484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13485 }
13486 arg1 = reinterpret_cast< wxImage * >(argp1);
13487 ecode2 = SWIG_AsVal_int(obj1, &val2);
13488 if (!SWIG_IsOK(ecode2)) {
13489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13490 }
13491 arg2 = static_cast< int >(val2);
13492 ecode3 = SWIG_AsVal_int(obj2, &val3);
13493 if (!SWIG_IsOK(ecode3)) {
13494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13495 }
13496 arg3 = static_cast< int >(val3);
13497 {
13498 PyThreadState* __tstate = wxPyBeginAllowThreads();
13499 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13500 wxPyEndAllowThreads(__tstate);
13501 if (PyErr_Occurred()) SWIG_fail;
13502 }
13503 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13504 return resultobj;
13505 fail:
13506 return NULL;
13507 }
13508
13509
13510 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj = 0;
13512 wxImage *arg1 = (wxImage *) 0 ;
13513 int arg2 ;
13514 int arg3 ;
13515 wxImage *result = 0 ;
13516 void *argp1 = 0 ;
13517 int res1 = 0 ;
13518 int val2 ;
13519 int ecode2 = 0 ;
13520 int val3 ;
13521 int ecode3 = 0 ;
13522 PyObject * obj0 = 0 ;
13523 PyObject * obj1 = 0 ;
13524 PyObject * obj2 = 0 ;
13525 char * kwnames[] = {
13526 (char *) "self",(char *) "width",(char *) "height", NULL
13527 };
13528
13529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13531 if (!SWIG_IsOK(res1)) {
13532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13533 }
13534 arg1 = reinterpret_cast< wxImage * >(argp1);
13535 ecode2 = SWIG_AsVal_int(obj1, &val2);
13536 if (!SWIG_IsOK(ecode2)) {
13537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13538 }
13539 arg2 = static_cast< int >(val2);
13540 ecode3 = SWIG_AsVal_int(obj2, &val3);
13541 if (!SWIG_IsOK(ecode3)) {
13542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13543 }
13544 arg3 = static_cast< int >(val3);
13545 {
13546 PyThreadState* __tstate = wxPyBeginAllowThreads();
13547 {
13548 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13549 result = (wxImage *) &_result_ref;
13550 }
13551 wxPyEndAllowThreads(__tstate);
13552 if (PyErr_Occurred()) SWIG_fail;
13553 }
13554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13555 return resultobj;
13556 fail:
13557 return NULL;
13558 }
13559
13560
13561 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13562 PyObject *resultobj = 0;
13563 wxImage *arg1 = (wxImage *) 0 ;
13564 wxSize *arg2 = 0 ;
13565 wxPoint *arg3 = 0 ;
13566 int arg4 = (int) -1 ;
13567 int arg5 = (int) -1 ;
13568 int arg6 = (int) -1 ;
13569 wxImage *result = 0 ;
13570 void *argp1 = 0 ;
13571 int res1 = 0 ;
13572 wxSize temp2 ;
13573 wxPoint temp3 ;
13574 int val4 ;
13575 int ecode4 = 0 ;
13576 int val5 ;
13577 int ecode5 = 0 ;
13578 int val6 ;
13579 int ecode6 = 0 ;
13580 PyObject * obj0 = 0 ;
13581 PyObject * obj1 = 0 ;
13582 PyObject * obj2 = 0 ;
13583 PyObject * obj3 = 0 ;
13584 PyObject * obj4 = 0 ;
13585 PyObject * obj5 = 0 ;
13586 char * kwnames[] = {
13587 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13588 };
13589
13590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13592 if (!SWIG_IsOK(res1)) {
13593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13594 }
13595 arg1 = reinterpret_cast< wxImage * >(argp1);
13596 {
13597 arg2 = &temp2;
13598 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13599 }
13600 {
13601 arg3 = &temp3;
13602 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13603 }
13604 if (obj3) {
13605 ecode4 = SWIG_AsVal_int(obj3, &val4);
13606 if (!SWIG_IsOK(ecode4)) {
13607 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13608 }
13609 arg4 = static_cast< int >(val4);
13610 }
13611 if (obj4) {
13612 ecode5 = SWIG_AsVal_int(obj4, &val5);
13613 if (!SWIG_IsOK(ecode5)) {
13614 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13615 }
13616 arg5 = static_cast< int >(val5);
13617 }
13618 if (obj5) {
13619 ecode6 = SWIG_AsVal_int(obj5, &val6);
13620 if (!SWIG_IsOK(ecode6)) {
13621 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13622 }
13623 arg6 = static_cast< int >(val6);
13624 }
13625 {
13626 PyThreadState* __tstate = wxPyBeginAllowThreads();
13627 {
13628 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13629 result = (wxImage *) &_result_ref;
13630 }
13631 wxPyEndAllowThreads(__tstate);
13632 if (PyErr_Occurred()) SWIG_fail;
13633 }
13634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13635 return resultobj;
13636 fail:
13637 return NULL;
13638 }
13639
13640
13641 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13642 PyObject *resultobj = 0;
13643 wxImage *arg1 = (wxImage *) 0 ;
13644 int arg2 ;
13645 int arg3 ;
13646 byte arg4 ;
13647 byte arg5 ;
13648 byte arg6 ;
13649 void *argp1 = 0 ;
13650 int res1 = 0 ;
13651 int val2 ;
13652 int ecode2 = 0 ;
13653 int val3 ;
13654 int ecode3 = 0 ;
13655 unsigned char val4 ;
13656 int ecode4 = 0 ;
13657 unsigned char val5 ;
13658 int ecode5 = 0 ;
13659 unsigned char val6 ;
13660 int ecode6 = 0 ;
13661 PyObject * obj0 = 0 ;
13662 PyObject * obj1 = 0 ;
13663 PyObject * obj2 = 0 ;
13664 PyObject * obj3 = 0 ;
13665 PyObject * obj4 = 0 ;
13666 PyObject * obj5 = 0 ;
13667 char * kwnames[] = {
13668 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13669 };
13670
13671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13673 if (!SWIG_IsOK(res1)) {
13674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13675 }
13676 arg1 = reinterpret_cast< wxImage * >(argp1);
13677 ecode2 = SWIG_AsVal_int(obj1, &val2);
13678 if (!SWIG_IsOK(ecode2)) {
13679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13680 }
13681 arg2 = static_cast< int >(val2);
13682 ecode3 = SWIG_AsVal_int(obj2, &val3);
13683 if (!SWIG_IsOK(ecode3)) {
13684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13685 }
13686 arg3 = static_cast< int >(val3);
13687 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13688 if (!SWIG_IsOK(ecode4)) {
13689 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13690 }
13691 arg4 = static_cast< byte >(val4);
13692 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13693 if (!SWIG_IsOK(ecode5)) {
13694 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13695 }
13696 arg5 = static_cast< byte >(val5);
13697 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13698 if (!SWIG_IsOK(ecode6)) {
13699 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13700 }
13701 arg6 = static_cast< byte >(val6);
13702 {
13703 PyThreadState* __tstate = wxPyBeginAllowThreads();
13704 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13705 wxPyEndAllowThreads(__tstate);
13706 if (PyErr_Occurred()) SWIG_fail;
13707 }
13708 resultobj = SWIG_Py_Void();
13709 return resultobj;
13710 fail:
13711 return NULL;
13712 }
13713
13714
13715 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13716 PyObject *resultobj = 0;
13717 wxImage *arg1 = (wxImage *) 0 ;
13718 wxRect *arg2 = 0 ;
13719 byte arg3 ;
13720 byte arg4 ;
13721 byte arg5 ;
13722 void *argp1 = 0 ;
13723 int res1 = 0 ;
13724 wxRect temp2 ;
13725 unsigned char val3 ;
13726 int ecode3 = 0 ;
13727 unsigned char val4 ;
13728 int ecode4 = 0 ;
13729 unsigned char val5 ;
13730 int ecode5 = 0 ;
13731 PyObject * obj0 = 0 ;
13732 PyObject * obj1 = 0 ;
13733 PyObject * obj2 = 0 ;
13734 PyObject * obj3 = 0 ;
13735 PyObject * obj4 = 0 ;
13736 char * kwnames[] = {
13737 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13738 };
13739
13740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13742 if (!SWIG_IsOK(res1)) {
13743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13744 }
13745 arg1 = reinterpret_cast< wxImage * >(argp1);
13746 {
13747 arg2 = &temp2;
13748 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13749 }
13750 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13751 if (!SWIG_IsOK(ecode3)) {
13752 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13753 }
13754 arg3 = static_cast< byte >(val3);
13755 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13756 if (!SWIG_IsOK(ecode4)) {
13757 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13758 }
13759 arg4 = static_cast< byte >(val4);
13760 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13761 if (!SWIG_IsOK(ecode5)) {
13762 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13763 }
13764 arg5 = static_cast< byte >(val5);
13765 {
13766 PyThreadState* __tstate = wxPyBeginAllowThreads();
13767 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13768 wxPyEndAllowThreads(__tstate);
13769 if (PyErr_Occurred()) SWIG_fail;
13770 }
13771 resultobj = SWIG_Py_Void();
13772 return resultobj;
13773 fail:
13774 return NULL;
13775 }
13776
13777
13778 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13779 PyObject *resultobj = 0;
13780 wxImage *arg1 = (wxImage *) 0 ;
13781 int arg2 ;
13782 int arg3 ;
13783 byte result;
13784 void *argp1 = 0 ;
13785 int res1 = 0 ;
13786 int val2 ;
13787 int ecode2 = 0 ;
13788 int val3 ;
13789 int ecode3 = 0 ;
13790 PyObject * obj0 = 0 ;
13791 PyObject * obj1 = 0 ;
13792 PyObject * obj2 = 0 ;
13793 char * kwnames[] = {
13794 (char *) "self",(char *) "x",(char *) "y", NULL
13795 };
13796
13797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13799 if (!SWIG_IsOK(res1)) {
13800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13801 }
13802 arg1 = reinterpret_cast< wxImage * >(argp1);
13803 ecode2 = SWIG_AsVal_int(obj1, &val2);
13804 if (!SWIG_IsOK(ecode2)) {
13805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13806 }
13807 arg2 = static_cast< int >(val2);
13808 ecode3 = SWIG_AsVal_int(obj2, &val3);
13809 if (!SWIG_IsOK(ecode3)) {
13810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13811 }
13812 arg3 = static_cast< int >(val3);
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 result = (byte)(arg1)->GetRed(arg2,arg3);
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13820 return resultobj;
13821 fail:
13822 return NULL;
13823 }
13824
13825
13826 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13827 PyObject *resultobj = 0;
13828 wxImage *arg1 = (wxImage *) 0 ;
13829 int arg2 ;
13830 int arg3 ;
13831 byte result;
13832 void *argp1 = 0 ;
13833 int res1 = 0 ;
13834 int val2 ;
13835 int ecode2 = 0 ;
13836 int val3 ;
13837 int ecode3 = 0 ;
13838 PyObject * obj0 = 0 ;
13839 PyObject * obj1 = 0 ;
13840 PyObject * obj2 = 0 ;
13841 char * kwnames[] = {
13842 (char *) "self",(char *) "x",(char *) "y", NULL
13843 };
13844
13845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13847 if (!SWIG_IsOK(res1)) {
13848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13849 }
13850 arg1 = reinterpret_cast< wxImage * >(argp1);
13851 ecode2 = SWIG_AsVal_int(obj1, &val2);
13852 if (!SWIG_IsOK(ecode2)) {
13853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13854 }
13855 arg2 = static_cast< int >(val2);
13856 ecode3 = SWIG_AsVal_int(obj2, &val3);
13857 if (!SWIG_IsOK(ecode3)) {
13858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13859 }
13860 arg3 = static_cast< int >(val3);
13861 {
13862 PyThreadState* __tstate = wxPyBeginAllowThreads();
13863 result = (byte)(arg1)->GetGreen(arg2,arg3);
13864 wxPyEndAllowThreads(__tstate);
13865 if (PyErr_Occurred()) SWIG_fail;
13866 }
13867 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13868 return resultobj;
13869 fail:
13870 return NULL;
13871 }
13872
13873
13874 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13875 PyObject *resultobj = 0;
13876 wxImage *arg1 = (wxImage *) 0 ;
13877 int arg2 ;
13878 int arg3 ;
13879 byte result;
13880 void *argp1 = 0 ;
13881 int res1 = 0 ;
13882 int val2 ;
13883 int ecode2 = 0 ;
13884 int val3 ;
13885 int ecode3 = 0 ;
13886 PyObject * obj0 = 0 ;
13887 PyObject * obj1 = 0 ;
13888 PyObject * obj2 = 0 ;
13889 char * kwnames[] = {
13890 (char *) "self",(char *) "x",(char *) "y", NULL
13891 };
13892
13893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13895 if (!SWIG_IsOK(res1)) {
13896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13897 }
13898 arg1 = reinterpret_cast< wxImage * >(argp1);
13899 ecode2 = SWIG_AsVal_int(obj1, &val2);
13900 if (!SWIG_IsOK(ecode2)) {
13901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13902 }
13903 arg2 = static_cast< int >(val2);
13904 ecode3 = SWIG_AsVal_int(obj2, &val3);
13905 if (!SWIG_IsOK(ecode3)) {
13906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13907 }
13908 arg3 = static_cast< int >(val3);
13909 {
13910 PyThreadState* __tstate = wxPyBeginAllowThreads();
13911 result = (byte)(arg1)->GetBlue(arg2,arg3);
13912 wxPyEndAllowThreads(__tstate);
13913 if (PyErr_Occurred()) SWIG_fail;
13914 }
13915 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13916 return resultobj;
13917 fail:
13918 return NULL;
13919 }
13920
13921
13922 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13923 PyObject *resultobj = 0;
13924 wxImage *arg1 = (wxImage *) 0 ;
13925 int arg2 ;
13926 int arg3 ;
13927 byte arg4 ;
13928 void *argp1 = 0 ;
13929 int res1 = 0 ;
13930 int val2 ;
13931 int ecode2 = 0 ;
13932 int val3 ;
13933 int ecode3 = 0 ;
13934 unsigned char val4 ;
13935 int ecode4 = 0 ;
13936 PyObject * obj0 = 0 ;
13937 PyObject * obj1 = 0 ;
13938 PyObject * obj2 = 0 ;
13939 PyObject * obj3 = 0 ;
13940 char * kwnames[] = {
13941 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13942 };
13943
13944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13946 if (!SWIG_IsOK(res1)) {
13947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13948 }
13949 arg1 = reinterpret_cast< wxImage * >(argp1);
13950 ecode2 = SWIG_AsVal_int(obj1, &val2);
13951 if (!SWIG_IsOK(ecode2)) {
13952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13953 }
13954 arg2 = static_cast< int >(val2);
13955 ecode3 = SWIG_AsVal_int(obj2, &val3);
13956 if (!SWIG_IsOK(ecode3)) {
13957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13958 }
13959 arg3 = static_cast< int >(val3);
13960 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13961 if (!SWIG_IsOK(ecode4)) {
13962 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13963 }
13964 arg4 = static_cast< byte >(val4);
13965 {
13966 PyThreadState* __tstate = wxPyBeginAllowThreads();
13967 (arg1)->SetAlpha(arg2,arg3,arg4);
13968 wxPyEndAllowThreads(__tstate);
13969 if (PyErr_Occurred()) SWIG_fail;
13970 }
13971 resultobj = SWIG_Py_Void();
13972 return resultobj;
13973 fail:
13974 return NULL;
13975 }
13976
13977
13978 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13979 PyObject *resultobj = 0;
13980 wxImage *arg1 = (wxImage *) 0 ;
13981 int arg2 ;
13982 int arg3 ;
13983 byte result;
13984 void *argp1 = 0 ;
13985 int res1 = 0 ;
13986 int val2 ;
13987 int ecode2 = 0 ;
13988 int val3 ;
13989 int ecode3 = 0 ;
13990 PyObject * obj0 = 0 ;
13991 PyObject * obj1 = 0 ;
13992 PyObject * obj2 = 0 ;
13993 char * kwnames[] = {
13994 (char *) "self",(char *) "x",(char *) "y", NULL
13995 };
13996
13997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13999 if (!SWIG_IsOK(res1)) {
14000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14001 }
14002 arg1 = reinterpret_cast< wxImage * >(argp1);
14003 ecode2 = SWIG_AsVal_int(obj1, &val2);
14004 if (!SWIG_IsOK(ecode2)) {
14005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14006 }
14007 arg2 = static_cast< int >(val2);
14008 ecode3 = SWIG_AsVal_int(obj2, &val3);
14009 if (!SWIG_IsOK(ecode3)) {
14010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14011 }
14012 arg3 = static_cast< int >(val3);
14013 {
14014 PyThreadState* __tstate = wxPyBeginAllowThreads();
14015 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14016 wxPyEndAllowThreads(__tstate);
14017 if (PyErr_Occurred()) SWIG_fail;
14018 }
14019 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14020 return resultobj;
14021 fail:
14022 return NULL;
14023 }
14024
14025
14026 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14027 PyObject *resultobj = 0;
14028 wxImage *arg1 = (wxImage *) 0 ;
14029 bool result;
14030 void *argp1 = 0 ;
14031 int res1 = 0 ;
14032 PyObject *swig_obj[1] ;
14033
14034 if (!args) SWIG_fail;
14035 swig_obj[0] = args;
14036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14037 if (!SWIG_IsOK(res1)) {
14038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14039 }
14040 arg1 = reinterpret_cast< wxImage * >(argp1);
14041 {
14042 PyThreadState* __tstate = wxPyBeginAllowThreads();
14043 result = (bool)(arg1)->HasAlpha();
14044 wxPyEndAllowThreads(__tstate);
14045 if (PyErr_Occurred()) SWIG_fail;
14046 }
14047 {
14048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14049 }
14050 return resultobj;
14051 fail:
14052 return NULL;
14053 }
14054
14055
14056 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14057 PyObject *resultobj = 0;
14058 wxImage *arg1 = (wxImage *) 0 ;
14059 void *argp1 = 0 ;
14060 int res1 = 0 ;
14061 PyObject *swig_obj[1] ;
14062
14063 if (!args) SWIG_fail;
14064 swig_obj[0] = args;
14065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14066 if (!SWIG_IsOK(res1)) {
14067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14068 }
14069 arg1 = reinterpret_cast< wxImage * >(argp1);
14070 {
14071 PyThreadState* __tstate = wxPyBeginAllowThreads();
14072 (arg1)->InitAlpha();
14073 wxPyEndAllowThreads(__tstate);
14074 if (PyErr_Occurred()) SWIG_fail;
14075 }
14076 resultobj = SWIG_Py_Void();
14077 return resultobj;
14078 fail:
14079 return NULL;
14080 }
14081
14082
14083 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14084 PyObject *resultobj = 0;
14085 wxImage *arg1 = (wxImage *) 0 ;
14086 int arg2 ;
14087 int arg3 ;
14088 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14089 bool result;
14090 void *argp1 = 0 ;
14091 int res1 = 0 ;
14092 int val2 ;
14093 int ecode2 = 0 ;
14094 int val3 ;
14095 int ecode3 = 0 ;
14096 unsigned char val4 ;
14097 int ecode4 = 0 ;
14098 PyObject * obj0 = 0 ;
14099 PyObject * obj1 = 0 ;
14100 PyObject * obj2 = 0 ;
14101 PyObject * obj3 = 0 ;
14102 char * kwnames[] = {
14103 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14104 };
14105
14106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14108 if (!SWIG_IsOK(res1)) {
14109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14110 }
14111 arg1 = reinterpret_cast< wxImage * >(argp1);
14112 ecode2 = SWIG_AsVal_int(obj1, &val2);
14113 if (!SWIG_IsOK(ecode2)) {
14114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14115 }
14116 arg2 = static_cast< int >(val2);
14117 ecode3 = SWIG_AsVal_int(obj2, &val3);
14118 if (!SWIG_IsOK(ecode3)) {
14119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14120 }
14121 arg3 = static_cast< int >(val3);
14122 if (obj3) {
14123 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14124 if (!SWIG_IsOK(ecode4)) {
14125 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14126 }
14127 arg4 = static_cast< byte >(val4);
14128 }
14129 {
14130 PyThreadState* __tstate = wxPyBeginAllowThreads();
14131 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14132 wxPyEndAllowThreads(__tstate);
14133 if (PyErr_Occurred()) SWIG_fail;
14134 }
14135 {
14136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14137 }
14138 return resultobj;
14139 fail:
14140 return NULL;
14141 }
14142
14143
14144 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14145 PyObject *resultobj = 0;
14146 wxImage *arg1 = (wxImage *) 0 ;
14147 byte *arg2 = (byte *) 0 ;
14148 byte *arg3 = (byte *) 0 ;
14149 byte *arg4 = (byte *) 0 ;
14150 byte arg5 = (byte) 0 ;
14151 byte arg6 = (byte) 0 ;
14152 byte arg7 = (byte) 0 ;
14153 bool result;
14154 void *argp1 = 0 ;
14155 int res1 = 0 ;
14156 byte temp2 ;
14157 int res2 = SWIG_TMPOBJ ;
14158 byte temp3 ;
14159 int res3 = SWIG_TMPOBJ ;
14160 byte temp4 ;
14161 int res4 = SWIG_TMPOBJ ;
14162 unsigned char val5 ;
14163 int ecode5 = 0 ;
14164 unsigned char val6 ;
14165 int ecode6 = 0 ;
14166 unsigned char val7 ;
14167 int ecode7 = 0 ;
14168 PyObject * obj0 = 0 ;
14169 PyObject * obj1 = 0 ;
14170 PyObject * obj2 = 0 ;
14171 PyObject * obj3 = 0 ;
14172 char * kwnames[] = {
14173 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14174 };
14175
14176 arg2 = &temp2;
14177 arg3 = &temp3;
14178 arg4 = &temp4;
14179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14181 if (!SWIG_IsOK(res1)) {
14182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14183 }
14184 arg1 = reinterpret_cast< wxImage * >(argp1);
14185 if (obj1) {
14186 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14187 if (!SWIG_IsOK(ecode5)) {
14188 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14189 }
14190 arg5 = static_cast< byte >(val5);
14191 }
14192 if (obj2) {
14193 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14194 if (!SWIG_IsOK(ecode6)) {
14195 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14196 }
14197 arg6 = static_cast< byte >(val6);
14198 }
14199 if (obj3) {
14200 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14201 if (!SWIG_IsOK(ecode7)) {
14202 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14203 }
14204 arg7 = static_cast< byte >(val7);
14205 }
14206 {
14207 PyThreadState* __tstate = wxPyBeginAllowThreads();
14208 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14209 wxPyEndAllowThreads(__tstate);
14210 if (PyErr_Occurred()) SWIG_fail;
14211 }
14212 {
14213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14214 }
14215 if (SWIG_IsTmpObj(res2)) {
14216 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14217 } else {
14218 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14219 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14220 }
14221 if (SWIG_IsTmpObj(res3)) {
14222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14223 } else {
14224 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14226 }
14227 if (SWIG_IsTmpObj(res4)) {
14228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14229 } else {
14230 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14232 }
14233 return resultobj;
14234 fail:
14235 return NULL;
14236 }
14237
14238
14239 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14240 PyObject *resultobj = 0;
14241 wxImage *arg1 = (wxImage *) 0 ;
14242 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14243 bool result;
14244 void *argp1 = 0 ;
14245 int res1 = 0 ;
14246 unsigned char val2 ;
14247 int ecode2 = 0 ;
14248 PyObject * obj0 = 0 ;
14249 PyObject * obj1 = 0 ;
14250 char * kwnames[] = {
14251 (char *) "self",(char *) "threshold", NULL
14252 };
14253
14254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14256 if (!SWIG_IsOK(res1)) {
14257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14258 }
14259 arg1 = reinterpret_cast< wxImage * >(argp1);
14260 if (obj1) {
14261 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14262 if (!SWIG_IsOK(ecode2)) {
14263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14264 }
14265 arg2 = static_cast< byte >(val2);
14266 }
14267 {
14268 PyThreadState* __tstate = wxPyBeginAllowThreads();
14269 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14270 wxPyEndAllowThreads(__tstate);
14271 if (PyErr_Occurred()) SWIG_fail;
14272 }
14273 {
14274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14275 }
14276 return resultobj;
14277 fail:
14278 return NULL;
14279 }
14280
14281
14282 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14283 PyObject *resultobj = 0;
14284 wxImage *arg1 = (wxImage *) 0 ;
14285 byte arg2 ;
14286 byte arg3 ;
14287 byte arg4 ;
14288 bool result;
14289 void *argp1 = 0 ;
14290 int res1 = 0 ;
14291 unsigned char val2 ;
14292 int ecode2 = 0 ;
14293 unsigned char val3 ;
14294 int ecode3 = 0 ;
14295 unsigned char val4 ;
14296 int ecode4 = 0 ;
14297 PyObject * obj0 = 0 ;
14298 PyObject * obj1 = 0 ;
14299 PyObject * obj2 = 0 ;
14300 PyObject * obj3 = 0 ;
14301 char * kwnames[] = {
14302 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14303 };
14304
14305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14307 if (!SWIG_IsOK(res1)) {
14308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14309 }
14310 arg1 = reinterpret_cast< wxImage * >(argp1);
14311 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14312 if (!SWIG_IsOK(ecode2)) {
14313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14314 }
14315 arg2 = static_cast< byte >(val2);
14316 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14317 if (!SWIG_IsOK(ecode3)) {
14318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14319 }
14320 arg3 = static_cast< byte >(val3);
14321 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14322 if (!SWIG_IsOK(ecode4)) {
14323 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14324 }
14325 arg4 = static_cast< byte >(val4);
14326 {
14327 PyThreadState* __tstate = wxPyBeginAllowThreads();
14328 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14329 wxPyEndAllowThreads(__tstate);
14330 if (PyErr_Occurred()) SWIG_fail;
14331 }
14332 {
14333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14334 }
14335 return resultobj;
14336 fail:
14337 return NULL;
14338 }
14339
14340
14341 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14342 PyObject *resultobj = 0;
14343 wxImage *arg1 = (wxImage *) 0 ;
14344 wxImage *arg2 = 0 ;
14345 byte arg3 ;
14346 byte arg4 ;
14347 byte arg5 ;
14348 bool result;
14349 void *argp1 = 0 ;
14350 int res1 = 0 ;
14351 void *argp2 = 0 ;
14352 int res2 = 0 ;
14353 unsigned char val3 ;
14354 int ecode3 = 0 ;
14355 unsigned char val4 ;
14356 int ecode4 = 0 ;
14357 unsigned char val5 ;
14358 int ecode5 = 0 ;
14359 PyObject * obj0 = 0 ;
14360 PyObject * obj1 = 0 ;
14361 PyObject * obj2 = 0 ;
14362 PyObject * obj3 = 0 ;
14363 PyObject * obj4 = 0 ;
14364 char * kwnames[] = {
14365 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14366 };
14367
14368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14370 if (!SWIG_IsOK(res1)) {
14371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14372 }
14373 arg1 = reinterpret_cast< wxImage * >(argp1);
14374 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14375 if (!SWIG_IsOK(res2)) {
14376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14377 }
14378 if (!argp2) {
14379 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14380 }
14381 arg2 = reinterpret_cast< wxImage * >(argp2);
14382 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14383 if (!SWIG_IsOK(ecode3)) {
14384 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14385 }
14386 arg3 = static_cast< byte >(val3);
14387 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14388 if (!SWIG_IsOK(ecode4)) {
14389 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14390 }
14391 arg4 = static_cast< byte >(val4);
14392 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14393 if (!SWIG_IsOK(ecode5)) {
14394 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14395 }
14396 arg5 = static_cast< byte >(val5);
14397 {
14398 PyThreadState* __tstate = wxPyBeginAllowThreads();
14399 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 {
14404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14405 }
14406 return resultobj;
14407 fail:
14408 return NULL;
14409 }
14410
14411
14412 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14413 PyObject *resultobj = 0;
14414 wxString *arg1 = 0 ;
14415 bool result;
14416 bool temp1 = false ;
14417 PyObject * obj0 = 0 ;
14418 char * kwnames[] = {
14419 (char *) "filename", NULL
14420 };
14421
14422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14423 {
14424 arg1 = wxString_in_helper(obj0);
14425 if (arg1 == NULL) SWIG_fail;
14426 temp1 = true;
14427 }
14428 {
14429 PyThreadState* __tstate = wxPyBeginAllowThreads();
14430 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14431 wxPyEndAllowThreads(__tstate);
14432 if (PyErr_Occurred()) SWIG_fail;
14433 }
14434 {
14435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14436 }
14437 {
14438 if (temp1)
14439 delete arg1;
14440 }
14441 return resultobj;
14442 fail:
14443 {
14444 if (temp1)
14445 delete arg1;
14446 }
14447 return NULL;
14448 }
14449
14450
14451 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14452 PyObject *resultobj = 0;
14453 wxString *arg1 = 0 ;
14454 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14455 int result;
14456 bool temp1 = false ;
14457 long val2 ;
14458 int ecode2 = 0 ;
14459 PyObject * obj0 = 0 ;
14460 PyObject * obj1 = 0 ;
14461 char * kwnames[] = {
14462 (char *) "filename",(char *) "type", NULL
14463 };
14464
14465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14466 {
14467 arg1 = wxString_in_helper(obj0);
14468 if (arg1 == NULL) SWIG_fail;
14469 temp1 = true;
14470 }
14471 if (obj1) {
14472 ecode2 = SWIG_AsVal_long(obj1, &val2);
14473 if (!SWIG_IsOK(ecode2)) {
14474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14475 }
14476 arg2 = static_cast< long >(val2);
14477 }
14478 {
14479 PyThreadState* __tstate = wxPyBeginAllowThreads();
14480 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14481 wxPyEndAllowThreads(__tstate);
14482 if (PyErr_Occurred()) SWIG_fail;
14483 }
14484 resultobj = SWIG_From_int(static_cast< int >(result));
14485 {
14486 if (temp1)
14487 delete arg1;
14488 }
14489 return resultobj;
14490 fail:
14491 {
14492 if (temp1)
14493 delete arg1;
14494 }
14495 return NULL;
14496 }
14497
14498
14499 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14500 PyObject *resultobj = 0;
14501 wxImage *arg1 = (wxImage *) 0 ;
14502 wxString *arg2 = 0 ;
14503 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14504 int arg4 = (int) -1 ;
14505 bool result;
14506 void *argp1 = 0 ;
14507 int res1 = 0 ;
14508 bool temp2 = false ;
14509 long val3 ;
14510 int ecode3 = 0 ;
14511 int val4 ;
14512 int ecode4 = 0 ;
14513 PyObject * obj0 = 0 ;
14514 PyObject * obj1 = 0 ;
14515 PyObject * obj2 = 0 ;
14516 PyObject * obj3 = 0 ;
14517 char * kwnames[] = {
14518 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14519 };
14520
14521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14523 if (!SWIG_IsOK(res1)) {
14524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14525 }
14526 arg1 = reinterpret_cast< wxImage * >(argp1);
14527 {
14528 arg2 = wxString_in_helper(obj1);
14529 if (arg2 == NULL) SWIG_fail;
14530 temp2 = true;
14531 }
14532 if (obj2) {
14533 ecode3 = SWIG_AsVal_long(obj2, &val3);
14534 if (!SWIG_IsOK(ecode3)) {
14535 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14536 }
14537 arg3 = static_cast< long >(val3);
14538 }
14539 if (obj3) {
14540 ecode4 = SWIG_AsVal_int(obj3, &val4);
14541 if (!SWIG_IsOK(ecode4)) {
14542 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14543 }
14544 arg4 = static_cast< int >(val4);
14545 }
14546 {
14547 PyThreadState* __tstate = wxPyBeginAllowThreads();
14548 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14549 wxPyEndAllowThreads(__tstate);
14550 if (PyErr_Occurred()) SWIG_fail;
14551 }
14552 {
14553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14554 }
14555 {
14556 if (temp2)
14557 delete arg2;
14558 }
14559 return resultobj;
14560 fail:
14561 {
14562 if (temp2)
14563 delete arg2;
14564 }
14565 return NULL;
14566 }
14567
14568
14569 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14570 PyObject *resultobj = 0;
14571 wxImage *arg1 = (wxImage *) 0 ;
14572 wxString *arg2 = 0 ;
14573 wxString *arg3 = 0 ;
14574 int arg4 = (int) -1 ;
14575 bool result;
14576 void *argp1 = 0 ;
14577 int res1 = 0 ;
14578 bool temp2 = false ;
14579 bool temp3 = false ;
14580 int val4 ;
14581 int ecode4 = 0 ;
14582 PyObject * obj0 = 0 ;
14583 PyObject * obj1 = 0 ;
14584 PyObject * obj2 = 0 ;
14585 PyObject * obj3 = 0 ;
14586 char * kwnames[] = {
14587 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14588 };
14589
14590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14592 if (!SWIG_IsOK(res1)) {
14593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14594 }
14595 arg1 = reinterpret_cast< wxImage * >(argp1);
14596 {
14597 arg2 = wxString_in_helper(obj1);
14598 if (arg2 == NULL) SWIG_fail;
14599 temp2 = true;
14600 }
14601 {
14602 arg3 = wxString_in_helper(obj2);
14603 if (arg3 == NULL) SWIG_fail;
14604 temp3 = true;
14605 }
14606 if (obj3) {
14607 ecode4 = SWIG_AsVal_int(obj3, &val4);
14608 if (!SWIG_IsOK(ecode4)) {
14609 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14610 }
14611 arg4 = static_cast< int >(val4);
14612 }
14613 {
14614 PyThreadState* __tstate = wxPyBeginAllowThreads();
14615 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14616 wxPyEndAllowThreads(__tstate);
14617 if (PyErr_Occurred()) SWIG_fail;
14618 }
14619 {
14620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14621 }
14622 {
14623 if (temp2)
14624 delete arg2;
14625 }
14626 {
14627 if (temp3)
14628 delete arg3;
14629 }
14630 return resultobj;
14631 fail:
14632 {
14633 if (temp2)
14634 delete arg2;
14635 }
14636 {
14637 if (temp3)
14638 delete arg3;
14639 }
14640 return NULL;
14641 }
14642
14643
14644 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14645 PyObject *resultobj = 0;
14646 wxImage *arg1 = (wxImage *) 0 ;
14647 wxString *arg2 = 0 ;
14648 int arg3 ;
14649 bool result;
14650 void *argp1 = 0 ;
14651 int res1 = 0 ;
14652 bool temp2 = false ;
14653 int val3 ;
14654 int ecode3 = 0 ;
14655 PyObject * obj0 = 0 ;
14656 PyObject * obj1 = 0 ;
14657 PyObject * obj2 = 0 ;
14658 char * kwnames[] = {
14659 (char *) "self",(char *) "name",(char *) "type", NULL
14660 };
14661
14662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14664 if (!SWIG_IsOK(res1)) {
14665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14666 }
14667 arg1 = reinterpret_cast< wxImage * >(argp1);
14668 {
14669 arg2 = wxString_in_helper(obj1);
14670 if (arg2 == NULL) SWIG_fail;
14671 temp2 = true;
14672 }
14673 ecode3 = SWIG_AsVal_int(obj2, &val3);
14674 if (!SWIG_IsOK(ecode3)) {
14675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14676 }
14677 arg3 = static_cast< int >(val3);
14678 {
14679 PyThreadState* __tstate = wxPyBeginAllowThreads();
14680 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14681 wxPyEndAllowThreads(__tstate);
14682 if (PyErr_Occurred()) SWIG_fail;
14683 }
14684 {
14685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14686 }
14687 {
14688 if (temp2)
14689 delete arg2;
14690 }
14691 return resultobj;
14692 fail:
14693 {
14694 if (temp2)
14695 delete arg2;
14696 }
14697 return NULL;
14698 }
14699
14700
14701 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14702 PyObject *resultobj = 0;
14703 wxImage *arg1 = (wxImage *) 0 ;
14704 wxString *arg2 = 0 ;
14705 wxString *arg3 = 0 ;
14706 bool result;
14707 void *argp1 = 0 ;
14708 int res1 = 0 ;
14709 bool temp2 = false ;
14710 bool temp3 = false ;
14711 PyObject * obj0 = 0 ;
14712 PyObject * obj1 = 0 ;
14713 PyObject * obj2 = 0 ;
14714 char * kwnames[] = {
14715 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14716 };
14717
14718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14720 if (!SWIG_IsOK(res1)) {
14721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14722 }
14723 arg1 = reinterpret_cast< wxImage * >(argp1);
14724 {
14725 arg2 = wxString_in_helper(obj1);
14726 if (arg2 == NULL) SWIG_fail;
14727 temp2 = true;
14728 }
14729 {
14730 arg3 = wxString_in_helper(obj2);
14731 if (arg3 == NULL) SWIG_fail;
14732 temp3 = true;
14733 }
14734 {
14735 PyThreadState* __tstate = wxPyBeginAllowThreads();
14736 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14737 wxPyEndAllowThreads(__tstate);
14738 if (PyErr_Occurred()) SWIG_fail;
14739 }
14740 {
14741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14742 }
14743 {
14744 if (temp2)
14745 delete arg2;
14746 }
14747 {
14748 if (temp3)
14749 delete arg3;
14750 }
14751 return resultobj;
14752 fail:
14753 {
14754 if (temp2)
14755 delete arg2;
14756 }
14757 {
14758 if (temp3)
14759 delete arg3;
14760 }
14761 return NULL;
14762 }
14763
14764
14765 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14766 PyObject *resultobj = 0;
14767 wxInputStream *arg1 = 0 ;
14768 bool result;
14769 wxPyInputStream *temp1 ;
14770 bool created1 ;
14771 PyObject * obj0 = 0 ;
14772 char * kwnames[] = {
14773 (char *) "stream", NULL
14774 };
14775
14776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14777 {
14778 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14779 arg1 = temp1->m_wxis;
14780 created1 = false;
14781 } else {
14782 PyErr_Clear(); // clear the failure of the wxPyConvert above
14783 arg1 = wxPyCBInputStream_create(obj0, false);
14784 if (arg1 == NULL) {
14785 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14786 SWIG_fail;
14787 }
14788 created1 = true;
14789 }
14790 }
14791 {
14792 PyThreadState* __tstate = wxPyBeginAllowThreads();
14793 result = (bool)wxImage::CanRead(*arg1);
14794 wxPyEndAllowThreads(__tstate);
14795 if (PyErr_Occurred()) SWIG_fail;
14796 }
14797 {
14798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14799 }
14800 {
14801 if (created1) delete arg1;
14802 }
14803 return resultobj;
14804 fail:
14805 {
14806 if (created1) delete arg1;
14807 }
14808 return NULL;
14809 }
14810
14811
14812 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14813 PyObject *resultobj = 0;
14814 wxImage *arg1 = (wxImage *) 0 ;
14815 wxInputStream *arg2 = 0 ;
14816 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14817 int arg4 = (int) -1 ;
14818 bool result;
14819 void *argp1 = 0 ;
14820 int res1 = 0 ;
14821 wxPyInputStream *temp2 ;
14822 bool created2 ;
14823 long val3 ;
14824 int ecode3 = 0 ;
14825 int val4 ;
14826 int ecode4 = 0 ;
14827 PyObject * obj0 = 0 ;
14828 PyObject * obj1 = 0 ;
14829 PyObject * obj2 = 0 ;
14830 PyObject * obj3 = 0 ;
14831 char * kwnames[] = {
14832 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14833 };
14834
14835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14837 if (!SWIG_IsOK(res1)) {
14838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14839 }
14840 arg1 = reinterpret_cast< wxImage * >(argp1);
14841 {
14842 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14843 arg2 = temp2->m_wxis;
14844 created2 = false;
14845 } else {
14846 PyErr_Clear(); // clear the failure of the wxPyConvert above
14847 arg2 = wxPyCBInputStream_create(obj1, false);
14848 if (arg2 == NULL) {
14849 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14850 SWIG_fail;
14851 }
14852 created2 = true;
14853 }
14854 }
14855 if (obj2) {
14856 ecode3 = SWIG_AsVal_long(obj2, &val3);
14857 if (!SWIG_IsOK(ecode3)) {
14858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14859 }
14860 arg3 = static_cast< long >(val3);
14861 }
14862 if (obj3) {
14863 ecode4 = SWIG_AsVal_int(obj3, &val4);
14864 if (!SWIG_IsOK(ecode4)) {
14865 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14866 }
14867 arg4 = static_cast< int >(val4);
14868 }
14869 {
14870 PyThreadState* __tstate = wxPyBeginAllowThreads();
14871 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14872 wxPyEndAllowThreads(__tstate);
14873 if (PyErr_Occurred()) SWIG_fail;
14874 }
14875 {
14876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14877 }
14878 {
14879 if (created2) delete arg2;
14880 }
14881 return resultobj;
14882 fail:
14883 {
14884 if (created2) delete arg2;
14885 }
14886 return NULL;
14887 }
14888
14889
14890 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14891 PyObject *resultobj = 0;
14892 wxImage *arg1 = (wxImage *) 0 ;
14893 wxInputStream *arg2 = 0 ;
14894 wxString *arg3 = 0 ;
14895 int arg4 = (int) -1 ;
14896 bool result;
14897 void *argp1 = 0 ;
14898 int res1 = 0 ;
14899 wxPyInputStream *temp2 ;
14900 bool created2 ;
14901 bool temp3 = false ;
14902 int val4 ;
14903 int ecode4 = 0 ;
14904 PyObject * obj0 = 0 ;
14905 PyObject * obj1 = 0 ;
14906 PyObject * obj2 = 0 ;
14907 PyObject * obj3 = 0 ;
14908 char * kwnames[] = {
14909 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14910 };
14911
14912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14914 if (!SWIG_IsOK(res1)) {
14915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14916 }
14917 arg1 = reinterpret_cast< wxImage * >(argp1);
14918 {
14919 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14920 arg2 = temp2->m_wxis;
14921 created2 = false;
14922 } else {
14923 PyErr_Clear(); // clear the failure of the wxPyConvert above
14924 arg2 = wxPyCBInputStream_create(obj1, false);
14925 if (arg2 == NULL) {
14926 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14927 SWIG_fail;
14928 }
14929 created2 = true;
14930 }
14931 }
14932 {
14933 arg3 = wxString_in_helper(obj2);
14934 if (arg3 == NULL) SWIG_fail;
14935 temp3 = true;
14936 }
14937 if (obj3) {
14938 ecode4 = SWIG_AsVal_int(obj3, &val4);
14939 if (!SWIG_IsOK(ecode4)) {
14940 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14941 }
14942 arg4 = static_cast< int >(val4);
14943 }
14944 {
14945 PyThreadState* __tstate = wxPyBeginAllowThreads();
14946 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14947 wxPyEndAllowThreads(__tstate);
14948 if (PyErr_Occurred()) SWIG_fail;
14949 }
14950 {
14951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14952 }
14953 {
14954 if (created2) delete arg2;
14955 }
14956 {
14957 if (temp3)
14958 delete arg3;
14959 }
14960 return resultobj;
14961 fail:
14962 {
14963 if (created2) delete arg2;
14964 }
14965 {
14966 if (temp3)
14967 delete arg3;
14968 }
14969 return NULL;
14970 }
14971
14972
14973 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14974 PyObject *resultobj = 0;
14975 wxImage *arg1 = (wxImage *) 0 ;
14976 bool result;
14977 void *argp1 = 0 ;
14978 int res1 = 0 ;
14979 PyObject *swig_obj[1] ;
14980
14981 if (!args) SWIG_fail;
14982 swig_obj[0] = args;
14983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14984 if (!SWIG_IsOK(res1)) {
14985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14986 }
14987 arg1 = reinterpret_cast< wxImage * >(argp1);
14988 {
14989 PyThreadState* __tstate = wxPyBeginAllowThreads();
14990 result = (bool)(arg1)->Ok();
14991 wxPyEndAllowThreads(__tstate);
14992 if (PyErr_Occurred()) SWIG_fail;
14993 }
14994 {
14995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14996 }
14997 return resultobj;
14998 fail:
14999 return NULL;
15000 }
15001
15002
15003 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15004 PyObject *resultobj = 0;
15005 wxImage *arg1 = (wxImage *) 0 ;
15006 int result;
15007 void *argp1 = 0 ;
15008 int res1 = 0 ;
15009 PyObject *swig_obj[1] ;
15010
15011 if (!args) SWIG_fail;
15012 swig_obj[0] = args;
15013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15014 if (!SWIG_IsOK(res1)) {
15015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15016 }
15017 arg1 = reinterpret_cast< wxImage * >(argp1);
15018 {
15019 PyThreadState* __tstate = wxPyBeginAllowThreads();
15020 result = (int)(arg1)->GetWidth();
15021 wxPyEndAllowThreads(__tstate);
15022 if (PyErr_Occurred()) SWIG_fail;
15023 }
15024 resultobj = SWIG_From_int(static_cast< int >(result));
15025 return resultobj;
15026 fail:
15027 return NULL;
15028 }
15029
15030
15031 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15032 PyObject *resultobj = 0;
15033 wxImage *arg1 = (wxImage *) 0 ;
15034 int result;
15035 void *argp1 = 0 ;
15036 int res1 = 0 ;
15037 PyObject *swig_obj[1] ;
15038
15039 if (!args) SWIG_fail;
15040 swig_obj[0] = args;
15041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15042 if (!SWIG_IsOK(res1)) {
15043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15044 }
15045 arg1 = reinterpret_cast< wxImage * >(argp1);
15046 {
15047 PyThreadState* __tstate = wxPyBeginAllowThreads();
15048 result = (int)(arg1)->GetHeight();
15049 wxPyEndAllowThreads(__tstate);
15050 if (PyErr_Occurred()) SWIG_fail;
15051 }
15052 resultobj = SWIG_From_int(static_cast< int >(result));
15053 return resultobj;
15054 fail:
15055 return NULL;
15056 }
15057
15058
15059 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15060 PyObject *resultobj = 0;
15061 wxImage *arg1 = (wxImage *) 0 ;
15062 wxSize result;
15063 void *argp1 = 0 ;
15064 int res1 = 0 ;
15065 PyObject *swig_obj[1] ;
15066
15067 if (!args) SWIG_fail;
15068 swig_obj[0] = args;
15069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15070 if (!SWIG_IsOK(res1)) {
15071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15072 }
15073 arg1 = reinterpret_cast< wxImage * >(argp1);
15074 {
15075 PyThreadState* __tstate = wxPyBeginAllowThreads();
15076 result = wxImage_GetSize(arg1);
15077 wxPyEndAllowThreads(__tstate);
15078 if (PyErr_Occurred()) SWIG_fail;
15079 }
15080 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15081 return resultobj;
15082 fail:
15083 return NULL;
15084 }
15085
15086
15087 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15088 PyObject *resultobj = 0;
15089 wxImage *arg1 = (wxImage *) 0 ;
15090 wxRect *arg2 = 0 ;
15091 SwigValueWrapper<wxImage > result;
15092 void *argp1 = 0 ;
15093 int res1 = 0 ;
15094 wxRect temp2 ;
15095 PyObject * obj0 = 0 ;
15096 PyObject * obj1 = 0 ;
15097 char * kwnames[] = {
15098 (char *) "self",(char *) "rect", NULL
15099 };
15100
15101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15103 if (!SWIG_IsOK(res1)) {
15104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15105 }
15106 arg1 = reinterpret_cast< wxImage * >(argp1);
15107 {
15108 arg2 = &temp2;
15109 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15110 }
15111 {
15112 PyThreadState* __tstate = wxPyBeginAllowThreads();
15113 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15114 wxPyEndAllowThreads(__tstate);
15115 if (PyErr_Occurred()) SWIG_fail;
15116 }
15117 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15118 return resultobj;
15119 fail:
15120 return NULL;
15121 }
15122
15123
15124 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15125 PyObject *resultobj = 0;
15126 wxImage *arg1 = (wxImage *) 0 ;
15127 wxSize *arg2 = 0 ;
15128 wxPoint *arg3 = 0 ;
15129 int arg4 = (int) -1 ;
15130 int arg5 = (int) -1 ;
15131 int arg6 = (int) -1 ;
15132 SwigValueWrapper<wxImage > result;
15133 void *argp1 = 0 ;
15134 int res1 = 0 ;
15135 wxSize temp2 ;
15136 wxPoint temp3 ;
15137 int val4 ;
15138 int ecode4 = 0 ;
15139 int val5 ;
15140 int ecode5 = 0 ;
15141 int val6 ;
15142 int ecode6 = 0 ;
15143 PyObject * obj0 = 0 ;
15144 PyObject * obj1 = 0 ;
15145 PyObject * obj2 = 0 ;
15146 PyObject * obj3 = 0 ;
15147 PyObject * obj4 = 0 ;
15148 PyObject * obj5 = 0 ;
15149 char * kwnames[] = {
15150 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15151 };
15152
15153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15155 if (!SWIG_IsOK(res1)) {
15156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15157 }
15158 arg1 = reinterpret_cast< wxImage * >(argp1);
15159 {
15160 arg2 = &temp2;
15161 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15162 }
15163 {
15164 arg3 = &temp3;
15165 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15166 }
15167 if (obj3) {
15168 ecode4 = SWIG_AsVal_int(obj3, &val4);
15169 if (!SWIG_IsOK(ecode4)) {
15170 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15171 }
15172 arg4 = static_cast< int >(val4);
15173 }
15174 if (obj4) {
15175 ecode5 = SWIG_AsVal_int(obj4, &val5);
15176 if (!SWIG_IsOK(ecode5)) {
15177 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15178 }
15179 arg5 = static_cast< int >(val5);
15180 }
15181 if (obj5) {
15182 ecode6 = SWIG_AsVal_int(obj5, &val6);
15183 if (!SWIG_IsOK(ecode6)) {
15184 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15185 }
15186 arg6 = static_cast< int >(val6);
15187 }
15188 {
15189 PyThreadState* __tstate = wxPyBeginAllowThreads();
15190 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15191 wxPyEndAllowThreads(__tstate);
15192 if (PyErr_Occurred()) SWIG_fail;
15193 }
15194 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15195 return resultobj;
15196 fail:
15197 return NULL;
15198 }
15199
15200
15201 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15202 PyObject *resultobj = 0;
15203 wxImage *arg1 = (wxImage *) 0 ;
15204 SwigValueWrapper<wxImage > result;
15205 void *argp1 = 0 ;
15206 int res1 = 0 ;
15207 PyObject *swig_obj[1] ;
15208
15209 if (!args) SWIG_fail;
15210 swig_obj[0] = args;
15211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15212 if (!SWIG_IsOK(res1)) {
15213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15214 }
15215 arg1 = reinterpret_cast< wxImage * >(argp1);
15216 {
15217 PyThreadState* __tstate = wxPyBeginAllowThreads();
15218 result = (arg1)->Copy();
15219 wxPyEndAllowThreads(__tstate);
15220 if (PyErr_Occurred()) SWIG_fail;
15221 }
15222 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15223 return resultobj;
15224 fail:
15225 return NULL;
15226 }
15227
15228
15229 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15230 PyObject *resultobj = 0;
15231 wxImage *arg1 = (wxImage *) 0 ;
15232 wxImage *arg2 = 0 ;
15233 int arg3 ;
15234 int arg4 ;
15235 void *argp1 = 0 ;
15236 int res1 = 0 ;
15237 void *argp2 = 0 ;
15238 int res2 = 0 ;
15239 int val3 ;
15240 int ecode3 = 0 ;
15241 int val4 ;
15242 int ecode4 = 0 ;
15243 PyObject * obj0 = 0 ;
15244 PyObject * obj1 = 0 ;
15245 PyObject * obj2 = 0 ;
15246 PyObject * obj3 = 0 ;
15247 char * kwnames[] = {
15248 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15249 };
15250
15251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15253 if (!SWIG_IsOK(res1)) {
15254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15255 }
15256 arg1 = reinterpret_cast< wxImage * >(argp1);
15257 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15258 if (!SWIG_IsOK(res2)) {
15259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15260 }
15261 if (!argp2) {
15262 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15263 }
15264 arg2 = reinterpret_cast< wxImage * >(argp2);
15265 ecode3 = SWIG_AsVal_int(obj2, &val3);
15266 if (!SWIG_IsOK(ecode3)) {
15267 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15268 }
15269 arg3 = static_cast< int >(val3);
15270 ecode4 = SWIG_AsVal_int(obj3, &val4);
15271 if (!SWIG_IsOK(ecode4)) {
15272 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15273 }
15274 arg4 = static_cast< int >(val4);
15275 {
15276 PyThreadState* __tstate = wxPyBeginAllowThreads();
15277 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15278 wxPyEndAllowThreads(__tstate);
15279 if (PyErr_Occurred()) SWIG_fail;
15280 }
15281 resultobj = SWIG_Py_Void();
15282 return resultobj;
15283 fail:
15284 return NULL;
15285 }
15286
15287
15288 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15289 PyObject *resultobj = 0;
15290 wxImage *arg1 = (wxImage *) 0 ;
15291 PyObject *result = 0 ;
15292 void *argp1 = 0 ;
15293 int res1 = 0 ;
15294 PyObject *swig_obj[1] ;
15295
15296 if (!args) SWIG_fail;
15297 swig_obj[0] = args;
15298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15299 if (!SWIG_IsOK(res1)) {
15300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15301 }
15302 arg1 = reinterpret_cast< wxImage * >(argp1);
15303 {
15304 PyThreadState* __tstate = wxPyBeginAllowThreads();
15305 result = (PyObject *)wxImage_GetData(arg1);
15306 wxPyEndAllowThreads(__tstate);
15307 if (PyErr_Occurred()) SWIG_fail;
15308 }
15309 resultobj = result;
15310 return resultobj;
15311 fail:
15312 return NULL;
15313 }
15314
15315
15316 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15317 PyObject *resultobj = 0;
15318 wxImage *arg1 = (wxImage *) 0 ;
15319 buffer arg2 ;
15320 int arg3 ;
15321 void *argp1 = 0 ;
15322 int res1 = 0 ;
15323 PyObject * obj0 = 0 ;
15324 PyObject * obj1 = 0 ;
15325 char * kwnames[] = {
15326 (char *) "self",(char *) "data", NULL
15327 };
15328
15329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15331 if (!SWIG_IsOK(res1)) {
15332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15333 }
15334 arg1 = reinterpret_cast< wxImage * >(argp1);
15335 {
15336 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15337 }
15338 {
15339 PyThreadState* __tstate = wxPyBeginAllowThreads();
15340 wxImage_SetData(arg1,arg2,arg3);
15341 wxPyEndAllowThreads(__tstate);
15342 if (PyErr_Occurred()) SWIG_fail;
15343 }
15344 resultobj = SWIG_Py_Void();
15345 return resultobj;
15346 fail:
15347 return NULL;
15348 }
15349
15350
15351 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15352 PyObject *resultobj = 0;
15353 wxImage *arg1 = (wxImage *) 0 ;
15354 PyObject *result = 0 ;
15355 void *argp1 = 0 ;
15356 int res1 = 0 ;
15357 PyObject *swig_obj[1] ;
15358
15359 if (!args) SWIG_fail;
15360 swig_obj[0] = args;
15361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15362 if (!SWIG_IsOK(res1)) {
15363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15364 }
15365 arg1 = reinterpret_cast< wxImage * >(argp1);
15366 {
15367 PyThreadState* __tstate = wxPyBeginAllowThreads();
15368 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15369 wxPyEndAllowThreads(__tstate);
15370 if (PyErr_Occurred()) SWIG_fail;
15371 }
15372 resultobj = result;
15373 return resultobj;
15374 fail:
15375 return NULL;
15376 }
15377
15378
15379 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15380 PyObject *resultobj = 0;
15381 wxImage *arg1 = (wxImage *) 0 ;
15382 buffer arg2 ;
15383 int arg3 ;
15384 void *argp1 = 0 ;
15385 int res1 = 0 ;
15386 PyObject * obj0 = 0 ;
15387 PyObject * obj1 = 0 ;
15388 char * kwnames[] = {
15389 (char *) "self",(char *) "data", NULL
15390 };
15391
15392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15396 }
15397 arg1 = reinterpret_cast< wxImage * >(argp1);
15398 {
15399 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15400 }
15401 {
15402 PyThreadState* __tstate = wxPyBeginAllowThreads();
15403 wxImage_SetDataBuffer(arg1,arg2,arg3);
15404 wxPyEndAllowThreads(__tstate);
15405 if (PyErr_Occurred()) SWIG_fail;
15406 }
15407 resultobj = SWIG_Py_Void();
15408 return resultobj;
15409 fail:
15410 return NULL;
15411 }
15412
15413
15414 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15415 PyObject *resultobj = 0;
15416 wxImage *arg1 = (wxImage *) 0 ;
15417 PyObject *result = 0 ;
15418 void *argp1 = 0 ;
15419 int res1 = 0 ;
15420 PyObject *swig_obj[1] ;
15421
15422 if (!args) SWIG_fail;
15423 swig_obj[0] = args;
15424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15425 if (!SWIG_IsOK(res1)) {
15426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15427 }
15428 arg1 = reinterpret_cast< wxImage * >(argp1);
15429 {
15430 PyThreadState* __tstate = wxPyBeginAllowThreads();
15431 result = (PyObject *)wxImage_GetAlphaData(arg1);
15432 wxPyEndAllowThreads(__tstate);
15433 if (PyErr_Occurred()) SWIG_fail;
15434 }
15435 resultobj = result;
15436 return resultobj;
15437 fail:
15438 return NULL;
15439 }
15440
15441
15442 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15443 PyObject *resultobj = 0;
15444 wxImage *arg1 = (wxImage *) 0 ;
15445 buffer arg2 ;
15446 int arg3 ;
15447 void *argp1 = 0 ;
15448 int res1 = 0 ;
15449 PyObject * obj0 = 0 ;
15450 PyObject * obj1 = 0 ;
15451 char * kwnames[] = {
15452 (char *) "self",(char *) "alpha", NULL
15453 };
15454
15455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15457 if (!SWIG_IsOK(res1)) {
15458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15459 }
15460 arg1 = reinterpret_cast< wxImage * >(argp1);
15461 {
15462 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15463 }
15464 {
15465 PyThreadState* __tstate = wxPyBeginAllowThreads();
15466 wxImage_SetAlphaData(arg1,arg2,arg3);
15467 wxPyEndAllowThreads(__tstate);
15468 if (PyErr_Occurred()) SWIG_fail;
15469 }
15470 resultobj = SWIG_Py_Void();
15471 return resultobj;
15472 fail:
15473 return NULL;
15474 }
15475
15476
15477 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15478 PyObject *resultobj = 0;
15479 wxImage *arg1 = (wxImage *) 0 ;
15480 PyObject *result = 0 ;
15481 void *argp1 = 0 ;
15482 int res1 = 0 ;
15483 PyObject *swig_obj[1] ;
15484
15485 if (!args) SWIG_fail;
15486 swig_obj[0] = args;
15487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15488 if (!SWIG_IsOK(res1)) {
15489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15490 }
15491 arg1 = reinterpret_cast< wxImage * >(argp1);
15492 {
15493 PyThreadState* __tstate = wxPyBeginAllowThreads();
15494 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15495 wxPyEndAllowThreads(__tstate);
15496 if (PyErr_Occurred()) SWIG_fail;
15497 }
15498 resultobj = result;
15499 return resultobj;
15500 fail:
15501 return NULL;
15502 }
15503
15504
15505 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15506 PyObject *resultobj = 0;
15507 wxImage *arg1 = (wxImage *) 0 ;
15508 buffer arg2 ;
15509 int arg3 ;
15510 void *argp1 = 0 ;
15511 int res1 = 0 ;
15512 PyObject * obj0 = 0 ;
15513 PyObject * obj1 = 0 ;
15514 char * kwnames[] = {
15515 (char *) "self",(char *) "alpha", NULL
15516 };
15517
15518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15520 if (!SWIG_IsOK(res1)) {
15521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15522 }
15523 arg1 = reinterpret_cast< wxImage * >(argp1);
15524 {
15525 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15526 }
15527 {
15528 PyThreadState* __tstate = wxPyBeginAllowThreads();
15529 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15530 wxPyEndAllowThreads(__tstate);
15531 if (PyErr_Occurred()) SWIG_fail;
15532 }
15533 resultobj = SWIG_Py_Void();
15534 return resultobj;
15535 fail:
15536 return NULL;
15537 }
15538
15539
15540 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15541 PyObject *resultobj = 0;
15542 wxImage *arg1 = (wxImage *) 0 ;
15543 byte arg2 ;
15544 byte arg3 ;
15545 byte arg4 ;
15546 void *argp1 = 0 ;
15547 int res1 = 0 ;
15548 unsigned char val2 ;
15549 int ecode2 = 0 ;
15550 unsigned char val3 ;
15551 int ecode3 = 0 ;
15552 unsigned char val4 ;
15553 int ecode4 = 0 ;
15554 PyObject * obj0 = 0 ;
15555 PyObject * obj1 = 0 ;
15556 PyObject * obj2 = 0 ;
15557 PyObject * obj3 = 0 ;
15558 char * kwnames[] = {
15559 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15560 };
15561
15562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15564 if (!SWIG_IsOK(res1)) {
15565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15566 }
15567 arg1 = reinterpret_cast< wxImage * >(argp1);
15568 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15569 if (!SWIG_IsOK(ecode2)) {
15570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15571 }
15572 arg2 = static_cast< byte >(val2);
15573 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15574 if (!SWIG_IsOK(ecode3)) {
15575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15576 }
15577 arg3 = static_cast< byte >(val3);
15578 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15579 if (!SWIG_IsOK(ecode4)) {
15580 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15581 }
15582 arg4 = static_cast< byte >(val4);
15583 {
15584 PyThreadState* __tstate = wxPyBeginAllowThreads();
15585 (arg1)->SetMaskColour(arg2,arg3,arg4);
15586 wxPyEndAllowThreads(__tstate);
15587 if (PyErr_Occurred()) SWIG_fail;
15588 }
15589 resultobj = SWIG_Py_Void();
15590 return resultobj;
15591 fail:
15592 return NULL;
15593 }
15594
15595
15596 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15597 PyObject *resultobj = 0;
15598 wxImage *arg1 = (wxImage *) 0 ;
15599 byte *arg2 = (byte *) 0 ;
15600 byte *arg3 = (byte *) 0 ;
15601 byte *arg4 = (byte *) 0 ;
15602 void *argp1 = 0 ;
15603 int res1 = 0 ;
15604 byte temp2 ;
15605 int res2 = SWIG_TMPOBJ ;
15606 byte temp3 ;
15607 int res3 = SWIG_TMPOBJ ;
15608 byte temp4 ;
15609 int res4 = SWIG_TMPOBJ ;
15610 PyObject *swig_obj[1] ;
15611
15612 arg2 = &temp2;
15613 arg3 = &temp3;
15614 arg4 = &temp4;
15615 if (!args) SWIG_fail;
15616 swig_obj[0] = args;
15617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15618 if (!SWIG_IsOK(res1)) {
15619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15620 }
15621 arg1 = reinterpret_cast< wxImage * >(argp1);
15622 {
15623 PyThreadState* __tstate = wxPyBeginAllowThreads();
15624 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15625 wxPyEndAllowThreads(__tstate);
15626 if (PyErr_Occurred()) SWIG_fail;
15627 }
15628 resultobj = SWIG_Py_Void();
15629 if (SWIG_IsTmpObj(res2)) {
15630 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15631 } else {
15632 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15634 }
15635 if (SWIG_IsTmpObj(res3)) {
15636 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15637 } else {
15638 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15639 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15640 }
15641 if (SWIG_IsTmpObj(res4)) {
15642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15643 } else {
15644 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15645 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15646 }
15647 return resultobj;
15648 fail:
15649 return NULL;
15650 }
15651
15652
15653 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15654 PyObject *resultobj = 0;
15655 wxImage *arg1 = (wxImage *) 0 ;
15656 byte result;
15657 void *argp1 = 0 ;
15658 int res1 = 0 ;
15659 PyObject *swig_obj[1] ;
15660
15661 if (!args) SWIG_fail;
15662 swig_obj[0] = args;
15663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15664 if (!SWIG_IsOK(res1)) {
15665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15666 }
15667 arg1 = reinterpret_cast< wxImage * >(argp1);
15668 {
15669 PyThreadState* __tstate = wxPyBeginAllowThreads();
15670 result = (byte)(arg1)->GetMaskRed();
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15682 PyObject *resultobj = 0;
15683 wxImage *arg1 = (wxImage *) 0 ;
15684 byte result;
15685 void *argp1 = 0 ;
15686 int res1 = 0 ;
15687 PyObject *swig_obj[1] ;
15688
15689 if (!args) SWIG_fail;
15690 swig_obj[0] = args;
15691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15692 if (!SWIG_IsOK(res1)) {
15693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15694 }
15695 arg1 = reinterpret_cast< wxImage * >(argp1);
15696 {
15697 PyThreadState* __tstate = wxPyBeginAllowThreads();
15698 result = (byte)(arg1)->GetMaskGreen();
15699 wxPyEndAllowThreads(__tstate);
15700 if (PyErr_Occurred()) SWIG_fail;
15701 }
15702 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15703 return resultobj;
15704 fail:
15705 return NULL;
15706 }
15707
15708
15709 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15710 PyObject *resultobj = 0;
15711 wxImage *arg1 = (wxImage *) 0 ;
15712 byte result;
15713 void *argp1 = 0 ;
15714 int res1 = 0 ;
15715 PyObject *swig_obj[1] ;
15716
15717 if (!args) SWIG_fail;
15718 swig_obj[0] = args;
15719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15720 if (!SWIG_IsOK(res1)) {
15721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15722 }
15723 arg1 = reinterpret_cast< wxImage * >(argp1);
15724 {
15725 PyThreadState* __tstate = wxPyBeginAllowThreads();
15726 result = (byte)(arg1)->GetMaskBlue();
15727 wxPyEndAllowThreads(__tstate);
15728 if (PyErr_Occurred()) SWIG_fail;
15729 }
15730 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15738 PyObject *resultobj = 0;
15739 wxImage *arg1 = (wxImage *) 0 ;
15740 bool arg2 = (bool) true ;
15741 void *argp1 = 0 ;
15742 int res1 = 0 ;
15743 bool val2 ;
15744 int ecode2 = 0 ;
15745 PyObject * obj0 = 0 ;
15746 PyObject * obj1 = 0 ;
15747 char * kwnames[] = {
15748 (char *) "self",(char *) "mask", NULL
15749 };
15750
15751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15753 if (!SWIG_IsOK(res1)) {
15754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15755 }
15756 arg1 = reinterpret_cast< wxImage * >(argp1);
15757 if (obj1) {
15758 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15759 if (!SWIG_IsOK(ecode2)) {
15760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15761 }
15762 arg2 = static_cast< bool >(val2);
15763 }
15764 {
15765 PyThreadState* __tstate = wxPyBeginAllowThreads();
15766 (arg1)->SetMask(arg2);
15767 wxPyEndAllowThreads(__tstate);
15768 if (PyErr_Occurred()) SWIG_fail;
15769 }
15770 resultobj = SWIG_Py_Void();
15771 return resultobj;
15772 fail:
15773 return NULL;
15774 }
15775
15776
15777 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15778 PyObject *resultobj = 0;
15779 wxImage *arg1 = (wxImage *) 0 ;
15780 bool result;
15781 void *argp1 = 0 ;
15782 int res1 = 0 ;
15783 PyObject *swig_obj[1] ;
15784
15785 if (!args) SWIG_fail;
15786 swig_obj[0] = args;
15787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15788 if (!SWIG_IsOK(res1)) {
15789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15790 }
15791 arg1 = reinterpret_cast< wxImage * >(argp1);
15792 {
15793 PyThreadState* __tstate = wxPyBeginAllowThreads();
15794 result = (bool)(arg1)->HasMask();
15795 wxPyEndAllowThreads(__tstate);
15796 if (PyErr_Occurred()) SWIG_fail;
15797 }
15798 {
15799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15800 }
15801 return resultobj;
15802 fail:
15803 return NULL;
15804 }
15805
15806
15807 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15808 PyObject *resultobj = 0;
15809 wxImage *arg1 = (wxImage *) 0 ;
15810 double arg2 ;
15811 wxPoint *arg3 = 0 ;
15812 bool arg4 = (bool) true ;
15813 wxPoint *arg5 = (wxPoint *) NULL ;
15814 SwigValueWrapper<wxImage > result;
15815 void *argp1 = 0 ;
15816 int res1 = 0 ;
15817 double val2 ;
15818 int ecode2 = 0 ;
15819 wxPoint temp3 ;
15820 bool val4 ;
15821 int ecode4 = 0 ;
15822 void *argp5 = 0 ;
15823 int res5 = 0 ;
15824 PyObject * obj0 = 0 ;
15825 PyObject * obj1 = 0 ;
15826 PyObject * obj2 = 0 ;
15827 PyObject * obj3 = 0 ;
15828 PyObject * obj4 = 0 ;
15829 char * kwnames[] = {
15830 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15831 };
15832
15833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15835 if (!SWIG_IsOK(res1)) {
15836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15837 }
15838 arg1 = reinterpret_cast< wxImage * >(argp1);
15839 ecode2 = SWIG_AsVal_double(obj1, &val2);
15840 if (!SWIG_IsOK(ecode2)) {
15841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15842 }
15843 arg2 = static_cast< double >(val2);
15844 {
15845 arg3 = &temp3;
15846 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15847 }
15848 if (obj3) {
15849 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15850 if (!SWIG_IsOK(ecode4)) {
15851 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15852 }
15853 arg4 = static_cast< bool >(val4);
15854 }
15855 if (obj4) {
15856 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15857 if (!SWIG_IsOK(res5)) {
15858 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15859 }
15860 arg5 = reinterpret_cast< wxPoint * >(argp5);
15861 }
15862 {
15863 PyThreadState* __tstate = wxPyBeginAllowThreads();
15864 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15865 wxPyEndAllowThreads(__tstate);
15866 if (PyErr_Occurred()) SWIG_fail;
15867 }
15868 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15869 return resultobj;
15870 fail:
15871 return NULL;
15872 }
15873
15874
15875 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15876 PyObject *resultobj = 0;
15877 wxImage *arg1 = (wxImage *) 0 ;
15878 bool arg2 = (bool) true ;
15879 SwigValueWrapper<wxImage > result;
15880 void *argp1 = 0 ;
15881 int res1 = 0 ;
15882 bool val2 ;
15883 int ecode2 = 0 ;
15884 PyObject * obj0 = 0 ;
15885 PyObject * obj1 = 0 ;
15886 char * kwnames[] = {
15887 (char *) "self",(char *) "clockwise", NULL
15888 };
15889
15890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15892 if (!SWIG_IsOK(res1)) {
15893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15894 }
15895 arg1 = reinterpret_cast< wxImage * >(argp1);
15896 if (obj1) {
15897 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15898 if (!SWIG_IsOK(ecode2)) {
15899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15900 }
15901 arg2 = static_cast< bool >(val2);
15902 }
15903 {
15904 PyThreadState* __tstate = wxPyBeginAllowThreads();
15905 result = (arg1)->Rotate90(arg2);
15906 wxPyEndAllowThreads(__tstate);
15907 if (PyErr_Occurred()) SWIG_fail;
15908 }
15909 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15910 return resultobj;
15911 fail:
15912 return NULL;
15913 }
15914
15915
15916 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15917 PyObject *resultobj = 0;
15918 wxImage *arg1 = (wxImage *) 0 ;
15919 bool arg2 = (bool) true ;
15920 SwigValueWrapper<wxImage > result;
15921 void *argp1 = 0 ;
15922 int res1 = 0 ;
15923 bool val2 ;
15924 int ecode2 = 0 ;
15925 PyObject * obj0 = 0 ;
15926 PyObject * obj1 = 0 ;
15927 char * kwnames[] = {
15928 (char *) "self",(char *) "horizontally", NULL
15929 };
15930
15931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15933 if (!SWIG_IsOK(res1)) {
15934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15935 }
15936 arg1 = reinterpret_cast< wxImage * >(argp1);
15937 if (obj1) {
15938 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15939 if (!SWIG_IsOK(ecode2)) {
15940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15941 }
15942 arg2 = static_cast< bool >(val2);
15943 }
15944 {
15945 PyThreadState* __tstate = wxPyBeginAllowThreads();
15946 result = (arg1)->Mirror(arg2);
15947 wxPyEndAllowThreads(__tstate);
15948 if (PyErr_Occurred()) SWIG_fail;
15949 }
15950 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15951 return resultobj;
15952 fail:
15953 return NULL;
15954 }
15955
15956
15957 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15958 PyObject *resultobj = 0;
15959 wxImage *arg1 = (wxImage *) 0 ;
15960 byte arg2 ;
15961 byte arg3 ;
15962 byte arg4 ;
15963 byte arg5 ;
15964 byte arg6 ;
15965 byte arg7 ;
15966 void *argp1 = 0 ;
15967 int res1 = 0 ;
15968 unsigned char val2 ;
15969 int ecode2 = 0 ;
15970 unsigned char val3 ;
15971 int ecode3 = 0 ;
15972 unsigned char val4 ;
15973 int ecode4 = 0 ;
15974 unsigned char val5 ;
15975 int ecode5 = 0 ;
15976 unsigned char val6 ;
15977 int ecode6 = 0 ;
15978 unsigned char val7 ;
15979 int ecode7 = 0 ;
15980 PyObject * obj0 = 0 ;
15981 PyObject * obj1 = 0 ;
15982 PyObject * obj2 = 0 ;
15983 PyObject * obj3 = 0 ;
15984 PyObject * obj4 = 0 ;
15985 PyObject * obj5 = 0 ;
15986 PyObject * obj6 = 0 ;
15987 char * kwnames[] = {
15988 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15989 };
15990
15991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15993 if (!SWIG_IsOK(res1)) {
15994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15995 }
15996 arg1 = reinterpret_cast< wxImage * >(argp1);
15997 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15998 if (!SWIG_IsOK(ecode2)) {
15999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16000 }
16001 arg2 = static_cast< byte >(val2);
16002 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16003 if (!SWIG_IsOK(ecode3)) {
16004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16005 }
16006 arg3 = static_cast< byte >(val3);
16007 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16008 if (!SWIG_IsOK(ecode4)) {
16009 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16010 }
16011 arg4 = static_cast< byte >(val4);
16012 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16013 if (!SWIG_IsOK(ecode5)) {
16014 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16015 }
16016 arg5 = static_cast< byte >(val5);
16017 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16018 if (!SWIG_IsOK(ecode6)) {
16019 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16020 }
16021 arg6 = static_cast< byte >(val6);
16022 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16023 if (!SWIG_IsOK(ecode7)) {
16024 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16025 }
16026 arg7 = static_cast< byte >(val7);
16027 {
16028 PyThreadState* __tstate = wxPyBeginAllowThreads();
16029 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16030 wxPyEndAllowThreads(__tstate);
16031 if (PyErr_Occurred()) SWIG_fail;
16032 }
16033 resultobj = SWIG_Py_Void();
16034 return resultobj;
16035 fail:
16036 return NULL;
16037 }
16038
16039
16040 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16041 PyObject *resultobj = 0;
16042 wxImage *arg1 = (wxImage *) 0 ;
16043 double arg2 = (double) 0.299 ;
16044 double arg3 = (double) 0.587 ;
16045 double arg4 = (double) 0.114 ;
16046 SwigValueWrapper<wxImage > result;
16047 void *argp1 = 0 ;
16048 int res1 = 0 ;
16049 double val2 ;
16050 int ecode2 = 0 ;
16051 double val3 ;
16052 int ecode3 = 0 ;
16053 double val4 ;
16054 int ecode4 = 0 ;
16055 PyObject * obj0 = 0 ;
16056 PyObject * obj1 = 0 ;
16057 PyObject * obj2 = 0 ;
16058 PyObject * obj3 = 0 ;
16059 char * kwnames[] = {
16060 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16061 };
16062
16063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16065 if (!SWIG_IsOK(res1)) {
16066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16067 }
16068 arg1 = reinterpret_cast< wxImage * >(argp1);
16069 if (obj1) {
16070 ecode2 = SWIG_AsVal_double(obj1, &val2);
16071 if (!SWIG_IsOK(ecode2)) {
16072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16073 }
16074 arg2 = static_cast< double >(val2);
16075 }
16076 if (obj2) {
16077 ecode3 = SWIG_AsVal_double(obj2, &val3);
16078 if (!SWIG_IsOK(ecode3)) {
16079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16080 }
16081 arg3 = static_cast< double >(val3);
16082 }
16083 if (obj3) {
16084 ecode4 = SWIG_AsVal_double(obj3, &val4);
16085 if (!SWIG_IsOK(ecode4)) {
16086 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16087 }
16088 arg4 = static_cast< double >(val4);
16089 }
16090 {
16091 PyThreadState* __tstate = wxPyBeginAllowThreads();
16092 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16093 wxPyEndAllowThreads(__tstate);
16094 if (PyErr_Occurred()) SWIG_fail;
16095 }
16096 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16097 return resultobj;
16098 fail:
16099 return NULL;
16100 }
16101
16102
16103 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16104 PyObject *resultobj = 0;
16105 wxImage *arg1 = (wxImage *) 0 ;
16106 byte arg2 ;
16107 byte arg3 ;
16108 byte arg4 ;
16109 SwigValueWrapper<wxImage > result;
16110 void *argp1 = 0 ;
16111 int res1 = 0 ;
16112 unsigned char val2 ;
16113 int ecode2 = 0 ;
16114 unsigned char val3 ;
16115 int ecode3 = 0 ;
16116 unsigned char val4 ;
16117 int ecode4 = 0 ;
16118 PyObject * obj0 = 0 ;
16119 PyObject * obj1 = 0 ;
16120 PyObject * obj2 = 0 ;
16121 PyObject * obj3 = 0 ;
16122 char * kwnames[] = {
16123 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16124 };
16125
16126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16128 if (!SWIG_IsOK(res1)) {
16129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16130 }
16131 arg1 = reinterpret_cast< wxImage * >(argp1);
16132 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16133 if (!SWIG_IsOK(ecode2)) {
16134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16135 }
16136 arg2 = static_cast< byte >(val2);
16137 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16138 if (!SWIG_IsOK(ecode3)) {
16139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16140 }
16141 arg3 = static_cast< byte >(val3);
16142 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16143 if (!SWIG_IsOK(ecode4)) {
16144 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16145 }
16146 arg4 = static_cast< byte >(val4);
16147 {
16148 PyThreadState* __tstate = wxPyBeginAllowThreads();
16149 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16150 wxPyEndAllowThreads(__tstate);
16151 if (PyErr_Occurred()) SWIG_fail;
16152 }
16153 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16154 return resultobj;
16155 fail:
16156 return NULL;
16157 }
16158
16159
16160 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16161 PyObject *resultobj = 0;
16162 wxImage *arg1 = (wxImage *) 0 ;
16163 wxString *arg2 = 0 ;
16164 wxString *arg3 = 0 ;
16165 void *argp1 = 0 ;
16166 int res1 = 0 ;
16167 bool temp2 = false ;
16168 bool temp3 = false ;
16169 PyObject * obj0 = 0 ;
16170 PyObject * obj1 = 0 ;
16171 PyObject * obj2 = 0 ;
16172 char * kwnames[] = {
16173 (char *) "self",(char *) "name",(char *) "value", NULL
16174 };
16175
16176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16178 if (!SWIG_IsOK(res1)) {
16179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16180 }
16181 arg1 = reinterpret_cast< wxImage * >(argp1);
16182 {
16183 arg2 = wxString_in_helper(obj1);
16184 if (arg2 == NULL) SWIG_fail;
16185 temp2 = true;
16186 }
16187 {
16188 arg3 = wxString_in_helper(obj2);
16189 if (arg3 == NULL) SWIG_fail;
16190 temp3 = true;
16191 }
16192 {
16193 PyThreadState* __tstate = wxPyBeginAllowThreads();
16194 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 resultobj = SWIG_Py_Void();
16199 {
16200 if (temp2)
16201 delete arg2;
16202 }
16203 {
16204 if (temp3)
16205 delete arg3;
16206 }
16207 return resultobj;
16208 fail:
16209 {
16210 if (temp2)
16211 delete arg2;
16212 }
16213 {
16214 if (temp3)
16215 delete arg3;
16216 }
16217 return NULL;
16218 }
16219
16220
16221 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16222 PyObject *resultobj = 0;
16223 wxImage *arg1 = (wxImage *) 0 ;
16224 wxString *arg2 = 0 ;
16225 int arg3 ;
16226 void *argp1 = 0 ;
16227 int res1 = 0 ;
16228 bool temp2 = false ;
16229 int val3 ;
16230 int ecode3 = 0 ;
16231 PyObject * obj0 = 0 ;
16232 PyObject * obj1 = 0 ;
16233 PyObject * obj2 = 0 ;
16234 char * kwnames[] = {
16235 (char *) "self",(char *) "name",(char *) "value", NULL
16236 };
16237
16238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16240 if (!SWIG_IsOK(res1)) {
16241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16242 }
16243 arg1 = reinterpret_cast< wxImage * >(argp1);
16244 {
16245 arg2 = wxString_in_helper(obj1);
16246 if (arg2 == NULL) SWIG_fail;
16247 temp2 = true;
16248 }
16249 ecode3 = SWIG_AsVal_int(obj2, &val3);
16250 if (!SWIG_IsOK(ecode3)) {
16251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16252 }
16253 arg3 = static_cast< int >(val3);
16254 {
16255 PyThreadState* __tstate = wxPyBeginAllowThreads();
16256 (arg1)->SetOption((wxString const &)*arg2,arg3);
16257 wxPyEndAllowThreads(__tstate);
16258 if (PyErr_Occurred()) SWIG_fail;
16259 }
16260 resultobj = SWIG_Py_Void();
16261 {
16262 if (temp2)
16263 delete arg2;
16264 }
16265 return resultobj;
16266 fail:
16267 {
16268 if (temp2)
16269 delete arg2;
16270 }
16271 return NULL;
16272 }
16273
16274
16275 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16276 PyObject *resultobj = 0;
16277 wxImage *arg1 = (wxImage *) 0 ;
16278 wxString *arg2 = 0 ;
16279 wxString result;
16280 void *argp1 = 0 ;
16281 int res1 = 0 ;
16282 bool temp2 = false ;
16283 PyObject * obj0 = 0 ;
16284 PyObject * obj1 = 0 ;
16285 char * kwnames[] = {
16286 (char *) "self",(char *) "name", NULL
16287 };
16288
16289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16291 if (!SWIG_IsOK(res1)) {
16292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16293 }
16294 arg1 = reinterpret_cast< wxImage * >(argp1);
16295 {
16296 arg2 = wxString_in_helper(obj1);
16297 if (arg2 == NULL) SWIG_fail;
16298 temp2 = true;
16299 }
16300 {
16301 PyThreadState* __tstate = wxPyBeginAllowThreads();
16302 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16303 wxPyEndAllowThreads(__tstate);
16304 if (PyErr_Occurred()) SWIG_fail;
16305 }
16306 {
16307 #if wxUSE_UNICODE
16308 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16309 #else
16310 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16311 #endif
16312 }
16313 {
16314 if (temp2)
16315 delete arg2;
16316 }
16317 return resultobj;
16318 fail:
16319 {
16320 if (temp2)
16321 delete arg2;
16322 }
16323 return NULL;
16324 }
16325
16326
16327 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16328 PyObject *resultobj = 0;
16329 wxImage *arg1 = (wxImage *) 0 ;
16330 wxString *arg2 = 0 ;
16331 int result;
16332 void *argp1 = 0 ;
16333 int res1 = 0 ;
16334 bool temp2 = false ;
16335 PyObject * obj0 = 0 ;
16336 PyObject * obj1 = 0 ;
16337 char * kwnames[] = {
16338 (char *) "self",(char *) "name", NULL
16339 };
16340
16341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16343 if (!SWIG_IsOK(res1)) {
16344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16345 }
16346 arg1 = reinterpret_cast< wxImage * >(argp1);
16347 {
16348 arg2 = wxString_in_helper(obj1);
16349 if (arg2 == NULL) SWIG_fail;
16350 temp2 = true;
16351 }
16352 {
16353 PyThreadState* __tstate = wxPyBeginAllowThreads();
16354 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16355 wxPyEndAllowThreads(__tstate);
16356 if (PyErr_Occurred()) SWIG_fail;
16357 }
16358 resultobj = SWIG_From_int(static_cast< int >(result));
16359 {
16360 if (temp2)
16361 delete arg2;
16362 }
16363 return resultobj;
16364 fail:
16365 {
16366 if (temp2)
16367 delete arg2;
16368 }
16369 return NULL;
16370 }
16371
16372
16373 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16374 PyObject *resultobj = 0;
16375 wxImage *arg1 = (wxImage *) 0 ;
16376 wxString *arg2 = 0 ;
16377 bool result;
16378 void *argp1 = 0 ;
16379 int res1 = 0 ;
16380 bool temp2 = false ;
16381 PyObject * obj0 = 0 ;
16382 PyObject * obj1 = 0 ;
16383 char * kwnames[] = {
16384 (char *) "self",(char *) "name", NULL
16385 };
16386
16387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16389 if (!SWIG_IsOK(res1)) {
16390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16391 }
16392 arg1 = reinterpret_cast< wxImage * >(argp1);
16393 {
16394 arg2 = wxString_in_helper(obj1);
16395 if (arg2 == NULL) SWIG_fail;
16396 temp2 = true;
16397 }
16398 {
16399 PyThreadState* __tstate = wxPyBeginAllowThreads();
16400 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16401 wxPyEndAllowThreads(__tstate);
16402 if (PyErr_Occurred()) SWIG_fail;
16403 }
16404 {
16405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16406 }
16407 {
16408 if (temp2)
16409 delete arg2;
16410 }
16411 return resultobj;
16412 fail:
16413 {
16414 if (temp2)
16415 delete arg2;
16416 }
16417 return NULL;
16418 }
16419
16420
16421 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16422 PyObject *resultobj = 0;
16423 wxImage *arg1 = (wxImage *) 0 ;
16424 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16425 unsigned long result;
16426 void *argp1 = 0 ;
16427 int res1 = 0 ;
16428 unsigned long val2 ;
16429 int ecode2 = 0 ;
16430 PyObject * obj0 = 0 ;
16431 PyObject * obj1 = 0 ;
16432 char * kwnames[] = {
16433 (char *) "self",(char *) "stopafter", NULL
16434 };
16435
16436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16438 if (!SWIG_IsOK(res1)) {
16439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16440 }
16441 arg1 = reinterpret_cast< wxImage * >(argp1);
16442 if (obj1) {
16443 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16444 if (!SWIG_IsOK(ecode2)) {
16445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16446 }
16447 arg2 = static_cast< unsigned long >(val2);
16448 }
16449 {
16450 PyThreadState* __tstate = wxPyBeginAllowThreads();
16451 result = (unsigned long)(arg1)->CountColours(arg2);
16452 wxPyEndAllowThreads(__tstate);
16453 if (PyErr_Occurred()) SWIG_fail;
16454 }
16455 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16456 return resultobj;
16457 fail:
16458 return NULL;
16459 }
16460
16461
16462 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16463 PyObject *resultobj = 0;
16464 wxImage *arg1 = (wxImage *) 0 ;
16465 wxImageHistogram *arg2 = 0 ;
16466 unsigned long result;
16467 void *argp1 = 0 ;
16468 int res1 = 0 ;
16469 void *argp2 = 0 ;
16470 int res2 = 0 ;
16471 PyObject * obj0 = 0 ;
16472 PyObject * obj1 = 0 ;
16473 char * kwnames[] = {
16474 (char *) "self",(char *) "h", NULL
16475 };
16476
16477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16479 if (!SWIG_IsOK(res1)) {
16480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16481 }
16482 arg1 = reinterpret_cast< wxImage * >(argp1);
16483 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16484 if (!SWIG_IsOK(res2)) {
16485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16486 }
16487 if (!argp2) {
16488 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16489 }
16490 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16491 {
16492 PyThreadState* __tstate = wxPyBeginAllowThreads();
16493 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16494 wxPyEndAllowThreads(__tstate);
16495 if (PyErr_Occurred()) SWIG_fail;
16496 }
16497 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16498 return resultobj;
16499 fail:
16500 return NULL;
16501 }
16502
16503
16504 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16505 PyObject *resultobj = 0;
16506 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16507 void *argp1 = 0 ;
16508 int res1 = 0 ;
16509 PyObject * obj0 = 0 ;
16510 char * kwnames[] = {
16511 (char *) "handler", NULL
16512 };
16513
16514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16516 if (!SWIG_IsOK(res1)) {
16517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16518 }
16519 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16520 {
16521 PyThreadState* __tstate = wxPyBeginAllowThreads();
16522 wxImage::AddHandler(arg1);
16523 wxPyEndAllowThreads(__tstate);
16524 if (PyErr_Occurred()) SWIG_fail;
16525 }
16526 resultobj = SWIG_Py_Void();
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj = 0;
16535 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16536 void *argp1 = 0 ;
16537 int res1 = 0 ;
16538 PyObject * obj0 = 0 ;
16539 char * kwnames[] = {
16540 (char *) "handler", NULL
16541 };
16542
16543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16545 if (!SWIG_IsOK(res1)) {
16546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16547 }
16548 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16549 {
16550 PyThreadState* __tstate = wxPyBeginAllowThreads();
16551 wxImage::InsertHandler(arg1);
16552 wxPyEndAllowThreads(__tstate);
16553 if (PyErr_Occurred()) SWIG_fail;
16554 }
16555 resultobj = SWIG_Py_Void();
16556 return resultobj;
16557 fail:
16558 return NULL;
16559 }
16560
16561
16562 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16563 PyObject *resultobj = 0;
16564 wxString *arg1 = 0 ;
16565 bool result;
16566 bool temp1 = false ;
16567 PyObject * obj0 = 0 ;
16568 char * kwnames[] = {
16569 (char *) "name", NULL
16570 };
16571
16572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16573 {
16574 arg1 = wxString_in_helper(obj0);
16575 if (arg1 == NULL) SWIG_fail;
16576 temp1 = true;
16577 }
16578 {
16579 PyThreadState* __tstate = wxPyBeginAllowThreads();
16580 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16581 wxPyEndAllowThreads(__tstate);
16582 if (PyErr_Occurred()) SWIG_fail;
16583 }
16584 {
16585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16586 }
16587 {
16588 if (temp1)
16589 delete arg1;
16590 }
16591 return resultobj;
16592 fail:
16593 {
16594 if (temp1)
16595 delete arg1;
16596 }
16597 return NULL;
16598 }
16599
16600
16601 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16602 PyObject *resultobj = 0;
16603 PyObject *result = 0 ;
16604
16605 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16606 {
16607 PyThreadState* __tstate = wxPyBeginAllowThreads();
16608 result = (PyObject *)wxImage_GetHandlers();
16609 wxPyEndAllowThreads(__tstate);
16610 if (PyErr_Occurred()) SWIG_fail;
16611 }
16612 resultobj = result;
16613 return resultobj;
16614 fail:
16615 return NULL;
16616 }
16617
16618
16619 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16620 PyObject *resultobj = 0;
16621 wxString result;
16622
16623 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16624 {
16625 PyThreadState* __tstate = wxPyBeginAllowThreads();
16626 result = wxImage::GetImageExtWildcard();
16627 wxPyEndAllowThreads(__tstate);
16628 if (PyErr_Occurred()) SWIG_fail;
16629 }
16630 {
16631 #if wxUSE_UNICODE
16632 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16633 #else
16634 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16635 #endif
16636 }
16637 return resultobj;
16638 fail:
16639 return NULL;
16640 }
16641
16642
16643 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16644 PyObject *resultobj = 0;
16645 wxImage *arg1 = (wxImage *) 0 ;
16646 int arg2 = (int) -1 ;
16647 wxBitmap result;
16648 void *argp1 = 0 ;
16649 int res1 = 0 ;
16650 int val2 ;
16651 int ecode2 = 0 ;
16652 PyObject * obj0 = 0 ;
16653 PyObject * obj1 = 0 ;
16654 char * kwnames[] = {
16655 (char *) "self",(char *) "depth", NULL
16656 };
16657
16658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16660 if (!SWIG_IsOK(res1)) {
16661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16662 }
16663 arg1 = reinterpret_cast< wxImage * >(argp1);
16664 if (obj1) {
16665 ecode2 = SWIG_AsVal_int(obj1, &val2);
16666 if (!SWIG_IsOK(ecode2)) {
16667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16668 }
16669 arg2 = static_cast< int >(val2);
16670 }
16671 {
16672 if (!wxPyCheckForApp()) SWIG_fail;
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 result = wxImage_ConvertToBitmap(arg1,arg2);
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16679 return resultobj;
16680 fail:
16681 return NULL;
16682 }
16683
16684
16685 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16686 PyObject *resultobj = 0;
16687 wxImage *arg1 = (wxImage *) 0 ;
16688 byte arg2 ;
16689 byte arg3 ;
16690 byte arg4 ;
16691 wxBitmap result;
16692 void *argp1 = 0 ;
16693 int res1 = 0 ;
16694 unsigned char val2 ;
16695 int ecode2 = 0 ;
16696 unsigned char val3 ;
16697 int ecode3 = 0 ;
16698 unsigned char val4 ;
16699 int ecode4 = 0 ;
16700 PyObject * obj0 = 0 ;
16701 PyObject * obj1 = 0 ;
16702 PyObject * obj2 = 0 ;
16703 PyObject * obj3 = 0 ;
16704 char * kwnames[] = {
16705 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16706 };
16707
16708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16710 if (!SWIG_IsOK(res1)) {
16711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16712 }
16713 arg1 = reinterpret_cast< wxImage * >(argp1);
16714 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16715 if (!SWIG_IsOK(ecode2)) {
16716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16717 }
16718 arg2 = static_cast< byte >(val2);
16719 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16720 if (!SWIG_IsOK(ecode3)) {
16721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16722 }
16723 arg3 = static_cast< byte >(val3);
16724 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16725 if (!SWIG_IsOK(ecode4)) {
16726 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16727 }
16728 arg4 = static_cast< byte >(val4);
16729 {
16730 if (!wxPyCheckForApp()) SWIG_fail;
16731 PyThreadState* __tstate = wxPyBeginAllowThreads();
16732 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16733 wxPyEndAllowThreads(__tstate);
16734 if (PyErr_Occurred()) SWIG_fail;
16735 }
16736 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16737 return resultobj;
16738 fail:
16739 return NULL;
16740 }
16741
16742
16743 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16744 PyObject *resultobj = 0;
16745 wxImage *arg1 = (wxImage *) 0 ;
16746 double arg2 ;
16747 void *argp1 = 0 ;
16748 int res1 = 0 ;
16749 double val2 ;
16750 int ecode2 = 0 ;
16751 PyObject * obj0 = 0 ;
16752 PyObject * obj1 = 0 ;
16753 char * kwnames[] = {
16754 (char *) "self",(char *) "angle", NULL
16755 };
16756
16757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16759 if (!SWIG_IsOK(res1)) {
16760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16761 }
16762 arg1 = reinterpret_cast< wxImage * >(argp1);
16763 ecode2 = SWIG_AsVal_double(obj1, &val2);
16764 if (!SWIG_IsOK(ecode2)) {
16765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16766 }
16767 arg2 = static_cast< double >(val2);
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 (arg1)->RotateHue(arg2);
16771 wxPyEndAllowThreads(__tstate);
16772 if (PyErr_Occurred()) SWIG_fail;
16773 }
16774 resultobj = SWIG_Py_Void();
16775 return resultobj;
16776 fail:
16777 return NULL;
16778 }
16779
16780
16781 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16782 PyObject *resultobj = 0;
16783 wxImage_RGBValue arg1 ;
16784 wxImage_HSVValue result;
16785 void *argp1 ;
16786 int res1 = 0 ;
16787 PyObject * obj0 = 0 ;
16788 char * kwnames[] = {
16789 (char *) "rgb", NULL
16790 };
16791
16792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16793 {
16794 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16795 if (!SWIG_IsOK(res1)) {
16796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16797 }
16798 if (!argp1) {
16799 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16800 } else {
16801 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16802 arg1 = *temp;
16803 if (SWIG_IsNewObj(res1)) delete temp;
16804 }
16805 }
16806 {
16807 PyThreadState* __tstate = wxPyBeginAllowThreads();
16808 result = wxImage::RGBtoHSV(arg1);
16809 wxPyEndAllowThreads(__tstate);
16810 if (PyErr_Occurred()) SWIG_fail;
16811 }
16812 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16813 return resultobj;
16814 fail:
16815 return NULL;
16816 }
16817
16818
16819 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16820 PyObject *resultobj = 0;
16821 wxImage_HSVValue arg1 ;
16822 wxImage_RGBValue result;
16823 void *argp1 ;
16824 int res1 = 0 ;
16825 PyObject * obj0 = 0 ;
16826 char * kwnames[] = {
16827 (char *) "hsv", NULL
16828 };
16829
16830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16831 {
16832 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16833 if (!SWIG_IsOK(res1)) {
16834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16835 }
16836 if (!argp1) {
16837 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16838 } else {
16839 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16840 arg1 = *temp;
16841 if (SWIG_IsNewObj(res1)) delete temp;
16842 }
16843 }
16844 {
16845 PyThreadState* __tstate = wxPyBeginAllowThreads();
16846 result = wxImage::HSVtoRGB(arg1);
16847 wxPyEndAllowThreads(__tstate);
16848 if (PyErr_Occurred()) SWIG_fail;
16849 }
16850 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16851 return resultobj;
16852 fail:
16853 return NULL;
16854 }
16855
16856
16857 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16858 PyObject *obj;
16859 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16860 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16861 return SWIG_Py_Void();
16862 }
16863
16864 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16865 return SWIG_Python_InitShadowInstance(args);
16866 }
16867
16868 SWIGINTERN int NullImage_set(PyObject *) {
16869 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16870 return 1;
16871 }
16872
16873
16874 SWIGINTERN PyObject *NullImage_get(void) {
16875 PyObject *pyobj = 0;
16876
16877 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16878 return pyobj;
16879 }
16880
16881
16882 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16883 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16884 return 1;
16885 }
16886
16887
16888 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16889 PyObject *pyobj = 0;
16890
16891 {
16892 #if wxUSE_UNICODE
16893 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16894 #else
16895 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16896 #endif
16897 }
16898 return pyobj;
16899 }
16900
16901
16902 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16903 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16904 return 1;
16905 }
16906
16907
16908 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16909 PyObject *pyobj = 0;
16910
16911 {
16912 #if wxUSE_UNICODE
16913 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16914 #else
16915 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16916 #endif
16917 }
16918 return pyobj;
16919 }
16920
16921
16922 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16923 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16924 return 1;
16925 }
16926
16927
16928 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16929 PyObject *pyobj = 0;
16930
16931 {
16932 #if wxUSE_UNICODE
16933 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16934 #else
16935 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16936 #endif
16937 }
16938 return pyobj;
16939 }
16940
16941
16942 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16943 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16944 return 1;
16945 }
16946
16947
16948 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16949 PyObject *pyobj = 0;
16950
16951 {
16952 #if wxUSE_UNICODE
16953 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16954 #else
16955 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16956 #endif
16957 }
16958 return pyobj;
16959 }
16960
16961
16962 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16963 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16964 return 1;
16965 }
16966
16967
16968 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16969 PyObject *pyobj = 0;
16970
16971 {
16972 #if wxUSE_UNICODE
16973 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16974 #else
16975 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16976 #endif
16977 }
16978 return pyobj;
16979 }
16980
16981
16982 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16983 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16984 return 1;
16985 }
16986
16987
16988 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16989 PyObject *pyobj = 0;
16990
16991 {
16992 #if wxUSE_UNICODE
16993 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16994 #else
16995 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16996 #endif
16997 }
16998 return pyobj;
16999 }
17000
17001
17002 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17003 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17004 return 1;
17005 }
17006
17007
17008 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17009 PyObject *pyobj = 0;
17010
17011 {
17012 #if wxUSE_UNICODE
17013 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17014 #else
17015 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17016 #endif
17017 }
17018 return pyobj;
17019 }
17020
17021
17022 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17023 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17024 return 1;
17025 }
17026
17027
17028 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17029 PyObject *pyobj = 0;
17030
17031 {
17032 #if wxUSE_UNICODE
17033 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17034 #else
17035 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17036 #endif
17037 }
17038 return pyobj;
17039 }
17040
17041
17042 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17043 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17044 return 1;
17045 }
17046
17047
17048 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17049 PyObject *pyobj = 0;
17050
17051 {
17052 #if wxUSE_UNICODE
17053 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17054 #else
17055 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17056 #endif
17057 }
17058 return pyobj;
17059 }
17060
17061
17062 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17063 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17064 return 1;
17065 }
17066
17067
17068 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17069 PyObject *pyobj = 0;
17070
17071 {
17072 #if wxUSE_UNICODE
17073 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17074 #else
17075 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17076 #endif
17077 }
17078 return pyobj;
17079 }
17080
17081
17082 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17083 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17084 return 1;
17085 }
17086
17087
17088 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17089 PyObject *pyobj = 0;
17090
17091 {
17092 #if wxUSE_UNICODE
17093 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17094 #else
17095 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17096 #endif
17097 }
17098 return pyobj;
17099 }
17100
17101
17102 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17103 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17104 return 1;
17105 }
17106
17107
17108 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17109 PyObject *pyobj = 0;
17110
17111 {
17112 #if wxUSE_UNICODE
17113 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17114 #else
17115 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17116 #endif
17117 }
17118 return pyobj;
17119 }
17120
17121
17122 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17123 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17124 return 1;
17125 }
17126
17127
17128 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17129 PyObject *pyobj = 0;
17130
17131 {
17132 #if wxUSE_UNICODE
17133 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17134 #else
17135 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17136 #endif
17137 }
17138 return pyobj;
17139 }
17140
17141
17142 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17143 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17144 return 1;
17145 }
17146
17147
17148 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17149 PyObject *pyobj = 0;
17150
17151 {
17152 #if wxUSE_UNICODE
17153 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17154 #else
17155 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17156 #endif
17157 }
17158 return pyobj;
17159 }
17160
17161
17162 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17163 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17164 return 1;
17165 }
17166
17167
17168 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17169 PyObject *pyobj = 0;
17170
17171 {
17172 #if wxUSE_UNICODE
17173 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17174 #else
17175 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17176 #endif
17177 }
17178 return pyobj;
17179 }
17180
17181
17182 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17183 PyObject *resultobj = 0;
17184 wxBMPHandler *result = 0 ;
17185
17186 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17187 {
17188 PyThreadState* __tstate = wxPyBeginAllowThreads();
17189 result = (wxBMPHandler *)new wxBMPHandler();
17190 wxPyEndAllowThreads(__tstate);
17191 if (PyErr_Occurred()) SWIG_fail;
17192 }
17193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17194 return resultobj;
17195 fail:
17196 return NULL;
17197 }
17198
17199
17200 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17201 PyObject *obj;
17202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17203 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17204 return SWIG_Py_Void();
17205 }
17206
17207 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17208 return SWIG_Python_InitShadowInstance(args);
17209 }
17210
17211 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17212 PyObject *resultobj = 0;
17213 wxICOHandler *result = 0 ;
17214
17215 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17216 {
17217 PyThreadState* __tstate = wxPyBeginAllowThreads();
17218 result = (wxICOHandler *)new wxICOHandler();
17219 wxPyEndAllowThreads(__tstate);
17220 if (PyErr_Occurred()) SWIG_fail;
17221 }
17222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17223 return resultobj;
17224 fail:
17225 return NULL;
17226 }
17227
17228
17229 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17230 PyObject *obj;
17231 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17232 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17233 return SWIG_Py_Void();
17234 }
17235
17236 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17237 return SWIG_Python_InitShadowInstance(args);
17238 }
17239
17240 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17241 PyObject *resultobj = 0;
17242 wxCURHandler *result = 0 ;
17243
17244 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17245 {
17246 PyThreadState* __tstate = wxPyBeginAllowThreads();
17247 result = (wxCURHandler *)new wxCURHandler();
17248 wxPyEndAllowThreads(__tstate);
17249 if (PyErr_Occurred()) SWIG_fail;
17250 }
17251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17252 return resultobj;
17253 fail:
17254 return NULL;
17255 }
17256
17257
17258 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17259 PyObject *obj;
17260 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17261 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17262 return SWIG_Py_Void();
17263 }
17264
17265 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17266 return SWIG_Python_InitShadowInstance(args);
17267 }
17268
17269 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17270 PyObject *resultobj = 0;
17271 wxANIHandler *result = 0 ;
17272
17273 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17274 {
17275 PyThreadState* __tstate = wxPyBeginAllowThreads();
17276 result = (wxANIHandler *)new wxANIHandler();
17277 wxPyEndAllowThreads(__tstate);
17278 if (PyErr_Occurred()) SWIG_fail;
17279 }
17280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17281 return resultobj;
17282 fail:
17283 return NULL;
17284 }
17285
17286
17287 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17288 PyObject *obj;
17289 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17290 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17291 return SWIG_Py_Void();
17292 }
17293
17294 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17295 return SWIG_Python_InitShadowInstance(args);
17296 }
17297
17298 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17299 PyObject *resultobj = 0;
17300 wxPNGHandler *result = 0 ;
17301
17302 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17303 {
17304 PyThreadState* __tstate = wxPyBeginAllowThreads();
17305 result = (wxPNGHandler *)new wxPNGHandler();
17306 wxPyEndAllowThreads(__tstate);
17307 if (PyErr_Occurred()) SWIG_fail;
17308 }
17309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17310 return resultobj;
17311 fail:
17312 return NULL;
17313 }
17314
17315
17316 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17317 PyObject *obj;
17318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17319 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17320 return SWIG_Py_Void();
17321 }
17322
17323 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17324 return SWIG_Python_InitShadowInstance(args);
17325 }
17326
17327 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17328 PyObject *resultobj = 0;
17329 wxGIFHandler *result = 0 ;
17330
17331 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17332 {
17333 PyThreadState* __tstate = wxPyBeginAllowThreads();
17334 result = (wxGIFHandler *)new wxGIFHandler();
17335 wxPyEndAllowThreads(__tstate);
17336 if (PyErr_Occurred()) SWIG_fail;
17337 }
17338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17339 return resultobj;
17340 fail:
17341 return NULL;
17342 }
17343
17344
17345 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17346 PyObject *obj;
17347 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17348 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17349 return SWIG_Py_Void();
17350 }
17351
17352 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17353 return SWIG_Python_InitShadowInstance(args);
17354 }
17355
17356 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17357 PyObject *resultobj = 0;
17358 wxPCXHandler *result = 0 ;
17359
17360 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17361 {
17362 PyThreadState* __tstate = wxPyBeginAllowThreads();
17363 result = (wxPCXHandler *)new wxPCXHandler();
17364 wxPyEndAllowThreads(__tstate);
17365 if (PyErr_Occurred()) SWIG_fail;
17366 }
17367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17368 return resultobj;
17369 fail:
17370 return NULL;
17371 }
17372
17373
17374 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17375 PyObject *obj;
17376 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17377 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17378 return SWIG_Py_Void();
17379 }
17380
17381 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17382 return SWIG_Python_InitShadowInstance(args);
17383 }
17384
17385 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17386 PyObject *resultobj = 0;
17387 wxJPEGHandler *result = 0 ;
17388
17389 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17390 {
17391 PyThreadState* __tstate = wxPyBeginAllowThreads();
17392 result = (wxJPEGHandler *)new wxJPEGHandler();
17393 wxPyEndAllowThreads(__tstate);
17394 if (PyErr_Occurred()) SWIG_fail;
17395 }
17396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17397 return resultobj;
17398 fail:
17399 return NULL;
17400 }
17401
17402
17403 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17404 PyObject *obj;
17405 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17406 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17407 return SWIG_Py_Void();
17408 }
17409
17410 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17411 return SWIG_Python_InitShadowInstance(args);
17412 }
17413
17414 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17415 PyObject *resultobj = 0;
17416 wxPNMHandler *result = 0 ;
17417
17418 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17419 {
17420 PyThreadState* __tstate = wxPyBeginAllowThreads();
17421 result = (wxPNMHandler *)new wxPNMHandler();
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17426 return resultobj;
17427 fail:
17428 return NULL;
17429 }
17430
17431
17432 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17433 PyObject *obj;
17434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17435 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17436 return SWIG_Py_Void();
17437 }
17438
17439 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17440 return SWIG_Python_InitShadowInstance(args);
17441 }
17442
17443 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17444 PyObject *resultobj = 0;
17445 wxXPMHandler *result = 0 ;
17446
17447 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17448 {
17449 PyThreadState* __tstate = wxPyBeginAllowThreads();
17450 result = (wxXPMHandler *)new wxXPMHandler();
17451 wxPyEndAllowThreads(__tstate);
17452 if (PyErr_Occurred()) SWIG_fail;
17453 }
17454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17455 return resultobj;
17456 fail:
17457 return NULL;
17458 }
17459
17460
17461 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17462 PyObject *obj;
17463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17464 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17465 return SWIG_Py_Void();
17466 }
17467
17468 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17469 return SWIG_Python_InitShadowInstance(args);
17470 }
17471
17472 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17473 PyObject *resultobj = 0;
17474 wxTIFFHandler *result = 0 ;
17475
17476 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17477 {
17478 PyThreadState* __tstate = wxPyBeginAllowThreads();
17479 result = (wxTIFFHandler *)new wxTIFFHandler();
17480 wxPyEndAllowThreads(__tstate);
17481 if (PyErr_Occurred()) SWIG_fail;
17482 }
17483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17484 return resultobj;
17485 fail:
17486 return NULL;
17487 }
17488
17489
17490 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17491 PyObject *obj;
17492 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17493 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17494 return SWIG_Py_Void();
17495 }
17496
17497 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17498 return SWIG_Python_InitShadowInstance(args);
17499 }
17500
17501 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17502 PyObject *resultobj = 0;
17503 wxImage *arg1 = 0 ;
17504 wxImage *arg2 = 0 ;
17505 int arg3 = (int) 236 ;
17506 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17507 bool result;
17508 void *argp1 = 0 ;
17509 int res1 = 0 ;
17510 void *argp2 = 0 ;
17511 int res2 = 0 ;
17512 int val3 ;
17513 int ecode3 = 0 ;
17514 int val4 ;
17515 int ecode4 = 0 ;
17516 PyObject * obj0 = 0 ;
17517 PyObject * obj1 = 0 ;
17518 PyObject * obj2 = 0 ;
17519 PyObject * obj3 = 0 ;
17520 char * kwnames[] = {
17521 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17522 };
17523
17524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17525 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17526 if (!SWIG_IsOK(res1)) {
17527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17528 }
17529 if (!argp1) {
17530 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17531 }
17532 arg1 = reinterpret_cast< wxImage * >(argp1);
17533 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17534 if (!SWIG_IsOK(res2)) {
17535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17536 }
17537 if (!argp2) {
17538 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17539 }
17540 arg2 = reinterpret_cast< wxImage * >(argp2);
17541 if (obj2) {
17542 ecode3 = SWIG_AsVal_int(obj2, &val3);
17543 if (!SWIG_IsOK(ecode3)) {
17544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17545 }
17546 arg3 = static_cast< int >(val3);
17547 }
17548 if (obj3) {
17549 ecode4 = SWIG_AsVal_int(obj3, &val4);
17550 if (!SWIG_IsOK(ecode4)) {
17551 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17552 }
17553 arg4 = static_cast< int >(val4);
17554 }
17555 {
17556 PyThreadState* __tstate = wxPyBeginAllowThreads();
17557 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17558 wxPyEndAllowThreads(__tstate);
17559 if (PyErr_Occurred()) SWIG_fail;
17560 }
17561 {
17562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17563 }
17564 return resultobj;
17565 fail:
17566 return NULL;
17567 }
17568
17569
17570 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17571 PyObject *obj;
17572 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17573 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17574 return SWIG_Py_Void();
17575 }
17576
17577 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17578 PyObject *resultobj = 0;
17579 wxEvtHandler *result = 0 ;
17580
17581 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17582 {
17583 PyThreadState* __tstate = wxPyBeginAllowThreads();
17584 result = (wxEvtHandler *)new wxEvtHandler();
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17589 return resultobj;
17590 fail:
17591 return NULL;
17592 }
17593
17594
17595 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17596 PyObject *resultobj = 0;
17597 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17598 wxEvtHandler *result = 0 ;
17599 void *argp1 = 0 ;
17600 int res1 = 0 ;
17601 PyObject *swig_obj[1] ;
17602
17603 if (!args) SWIG_fail;
17604 swig_obj[0] = args;
17605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17606 if (!SWIG_IsOK(res1)) {
17607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17608 }
17609 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17610 {
17611 PyThreadState* __tstate = wxPyBeginAllowThreads();
17612 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17613 wxPyEndAllowThreads(__tstate);
17614 if (PyErr_Occurred()) SWIG_fail;
17615 }
17616 {
17617 resultobj = wxPyMake_wxObject(result, 0);
17618 }
17619 return resultobj;
17620 fail:
17621 return NULL;
17622 }
17623
17624
17625 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17626 PyObject *resultobj = 0;
17627 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17628 wxEvtHandler *result = 0 ;
17629 void *argp1 = 0 ;
17630 int res1 = 0 ;
17631 PyObject *swig_obj[1] ;
17632
17633 if (!args) SWIG_fail;
17634 swig_obj[0] = args;
17635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17636 if (!SWIG_IsOK(res1)) {
17637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17638 }
17639 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17640 {
17641 PyThreadState* __tstate = wxPyBeginAllowThreads();
17642 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17643 wxPyEndAllowThreads(__tstate);
17644 if (PyErr_Occurred()) SWIG_fail;
17645 }
17646 {
17647 resultobj = wxPyMake_wxObject(result, 0);
17648 }
17649 return resultobj;
17650 fail:
17651 return NULL;
17652 }
17653
17654
17655 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17656 PyObject *resultobj = 0;
17657 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17658 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17659 void *argp1 = 0 ;
17660 int res1 = 0 ;
17661 void *argp2 = 0 ;
17662 int res2 = 0 ;
17663 PyObject * obj0 = 0 ;
17664 PyObject * obj1 = 0 ;
17665 char * kwnames[] = {
17666 (char *) "self",(char *) "handler", NULL
17667 };
17668
17669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17671 if (!SWIG_IsOK(res1)) {
17672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17673 }
17674 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17675 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17676 if (!SWIG_IsOK(res2)) {
17677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17678 }
17679 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17680 {
17681 PyThreadState* __tstate = wxPyBeginAllowThreads();
17682 (arg1)->SetNextHandler(arg2);
17683 wxPyEndAllowThreads(__tstate);
17684 if (PyErr_Occurred()) SWIG_fail;
17685 }
17686 resultobj = SWIG_Py_Void();
17687 return resultobj;
17688 fail:
17689 return NULL;
17690 }
17691
17692
17693 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17694 PyObject *resultobj = 0;
17695 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17696 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17697 void *argp1 = 0 ;
17698 int res1 = 0 ;
17699 void *argp2 = 0 ;
17700 int res2 = 0 ;
17701 PyObject * obj0 = 0 ;
17702 PyObject * obj1 = 0 ;
17703 char * kwnames[] = {
17704 (char *) "self",(char *) "handler", NULL
17705 };
17706
17707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17709 if (!SWIG_IsOK(res1)) {
17710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17711 }
17712 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17713 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17714 if (!SWIG_IsOK(res2)) {
17715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17716 }
17717 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17718 {
17719 PyThreadState* __tstate = wxPyBeginAllowThreads();
17720 (arg1)->SetPreviousHandler(arg2);
17721 wxPyEndAllowThreads(__tstate);
17722 if (PyErr_Occurred()) SWIG_fail;
17723 }
17724 resultobj = SWIG_Py_Void();
17725 return resultobj;
17726 fail:
17727 return NULL;
17728 }
17729
17730
17731 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17732 PyObject *resultobj = 0;
17733 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17734 bool result;
17735 void *argp1 = 0 ;
17736 int res1 = 0 ;
17737 PyObject *swig_obj[1] ;
17738
17739 if (!args) SWIG_fail;
17740 swig_obj[0] = args;
17741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17742 if (!SWIG_IsOK(res1)) {
17743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17744 }
17745 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17746 {
17747 PyThreadState* __tstate = wxPyBeginAllowThreads();
17748 result = (bool)(arg1)->GetEvtHandlerEnabled();
17749 wxPyEndAllowThreads(__tstate);
17750 if (PyErr_Occurred()) SWIG_fail;
17751 }
17752 {
17753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17754 }
17755 return resultobj;
17756 fail:
17757 return NULL;
17758 }
17759
17760
17761 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17762 PyObject *resultobj = 0;
17763 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17764 bool arg2 ;
17765 void *argp1 = 0 ;
17766 int res1 = 0 ;
17767 bool val2 ;
17768 int ecode2 = 0 ;
17769 PyObject * obj0 = 0 ;
17770 PyObject * obj1 = 0 ;
17771 char * kwnames[] = {
17772 (char *) "self",(char *) "enabled", NULL
17773 };
17774
17775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17777 if (!SWIG_IsOK(res1)) {
17778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17779 }
17780 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17781 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17782 if (!SWIG_IsOK(ecode2)) {
17783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17784 }
17785 arg2 = static_cast< bool >(val2);
17786 {
17787 PyThreadState* __tstate = wxPyBeginAllowThreads();
17788 (arg1)->SetEvtHandlerEnabled(arg2);
17789 wxPyEndAllowThreads(__tstate);
17790 if (PyErr_Occurred()) SWIG_fail;
17791 }
17792 resultobj = SWIG_Py_Void();
17793 return resultobj;
17794 fail:
17795 return NULL;
17796 }
17797
17798
17799 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17800 PyObject *resultobj = 0;
17801 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17802 wxEvent *arg2 = 0 ;
17803 bool result;
17804 void *argp1 = 0 ;
17805 int res1 = 0 ;
17806 void *argp2 = 0 ;
17807 int res2 = 0 ;
17808 PyObject * obj0 = 0 ;
17809 PyObject * obj1 = 0 ;
17810 char * kwnames[] = {
17811 (char *) "self",(char *) "event", NULL
17812 };
17813
17814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17816 if (!SWIG_IsOK(res1)) {
17817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17818 }
17819 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17820 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17821 if (!SWIG_IsOK(res2)) {
17822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17823 }
17824 if (!argp2) {
17825 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17826 }
17827 arg2 = reinterpret_cast< wxEvent * >(argp2);
17828 {
17829 PyThreadState* __tstate = wxPyBeginAllowThreads();
17830 result = (bool)(arg1)->ProcessEvent(*arg2);
17831 wxPyEndAllowThreads(__tstate);
17832 if (PyErr_Occurred()) SWIG_fail;
17833 }
17834 {
17835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17836 }
17837 return resultobj;
17838 fail:
17839 return NULL;
17840 }
17841
17842
17843 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17844 PyObject *resultobj = 0;
17845 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17846 wxEvent *arg2 = 0 ;
17847 void *argp1 = 0 ;
17848 int res1 = 0 ;
17849 void *argp2 = 0 ;
17850 int res2 = 0 ;
17851 PyObject * obj0 = 0 ;
17852 PyObject * obj1 = 0 ;
17853 char * kwnames[] = {
17854 (char *) "self",(char *) "event", NULL
17855 };
17856
17857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17859 if (!SWIG_IsOK(res1)) {
17860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17861 }
17862 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17863 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17864 if (!SWIG_IsOK(res2)) {
17865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17866 }
17867 if (!argp2) {
17868 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17869 }
17870 arg2 = reinterpret_cast< wxEvent * >(argp2);
17871 {
17872 PyThreadState* __tstate = wxPyBeginAllowThreads();
17873 (arg1)->AddPendingEvent(*arg2);
17874 wxPyEndAllowThreads(__tstate);
17875 if (PyErr_Occurred()) SWIG_fail;
17876 }
17877 resultobj = SWIG_Py_Void();
17878 return resultobj;
17879 fail:
17880 return NULL;
17881 }
17882
17883
17884 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17885 PyObject *resultobj = 0;
17886 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17887 void *argp1 = 0 ;
17888 int res1 = 0 ;
17889 PyObject *swig_obj[1] ;
17890
17891 if (!args) SWIG_fail;
17892 swig_obj[0] = args;
17893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17894 if (!SWIG_IsOK(res1)) {
17895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17896 }
17897 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17898 {
17899 PyThreadState* __tstate = wxPyBeginAllowThreads();
17900 (arg1)->ProcessPendingEvents();
17901 wxPyEndAllowThreads(__tstate);
17902 if (PyErr_Occurred()) SWIG_fail;
17903 }
17904 resultobj = SWIG_Py_Void();
17905 return resultobj;
17906 fail:
17907 return NULL;
17908 }
17909
17910
17911 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17912 PyObject *resultobj = 0;
17913 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17914 int arg2 ;
17915 int arg3 ;
17916 int arg4 ;
17917 PyObject *arg5 = (PyObject *) 0 ;
17918 void *argp1 = 0 ;
17919 int res1 = 0 ;
17920 int val2 ;
17921 int ecode2 = 0 ;
17922 int val3 ;
17923 int ecode3 = 0 ;
17924 int val4 ;
17925 int ecode4 = 0 ;
17926 PyObject * obj0 = 0 ;
17927 PyObject * obj1 = 0 ;
17928 PyObject * obj2 = 0 ;
17929 PyObject * obj3 = 0 ;
17930 PyObject * obj4 = 0 ;
17931 char * kwnames[] = {
17932 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17933 };
17934
17935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17937 if (!SWIG_IsOK(res1)) {
17938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17939 }
17940 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17941 ecode2 = SWIG_AsVal_int(obj1, &val2);
17942 if (!SWIG_IsOK(ecode2)) {
17943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17944 }
17945 arg2 = static_cast< int >(val2);
17946 ecode3 = SWIG_AsVal_int(obj2, &val3);
17947 if (!SWIG_IsOK(ecode3)) {
17948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17949 }
17950 arg3 = static_cast< int >(val3);
17951 ecode4 = SWIG_AsVal_int(obj3, &val4);
17952 if (!SWIG_IsOK(ecode4)) {
17953 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17954 }
17955 arg4 = static_cast< int >(val4);
17956 arg5 = obj4;
17957 {
17958 PyThreadState* __tstate = wxPyBeginAllowThreads();
17959 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17960 wxPyEndAllowThreads(__tstate);
17961 if (PyErr_Occurred()) SWIG_fail;
17962 }
17963 resultobj = SWIG_Py_Void();
17964 return resultobj;
17965 fail:
17966 return NULL;
17967 }
17968
17969
17970 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17971 PyObject *resultobj = 0;
17972 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17973 int arg2 ;
17974 int arg3 = (int) -1 ;
17975 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17976 bool result;
17977 void *argp1 = 0 ;
17978 int res1 = 0 ;
17979 int val2 ;
17980 int ecode2 = 0 ;
17981 int val3 ;
17982 int ecode3 = 0 ;
17983 int val4 ;
17984 int ecode4 = 0 ;
17985 PyObject * obj0 = 0 ;
17986 PyObject * obj1 = 0 ;
17987 PyObject * obj2 = 0 ;
17988 PyObject * obj3 = 0 ;
17989 char * kwnames[] = {
17990 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17991 };
17992
17993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17995 if (!SWIG_IsOK(res1)) {
17996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17997 }
17998 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17999 ecode2 = SWIG_AsVal_int(obj1, &val2);
18000 if (!SWIG_IsOK(ecode2)) {
18001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18002 }
18003 arg2 = static_cast< int >(val2);
18004 if (obj2) {
18005 ecode3 = SWIG_AsVal_int(obj2, &val3);
18006 if (!SWIG_IsOK(ecode3)) {
18007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18008 }
18009 arg3 = static_cast< int >(val3);
18010 }
18011 if (obj3) {
18012 ecode4 = SWIG_AsVal_int(obj3, &val4);
18013 if (!SWIG_IsOK(ecode4)) {
18014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18015 }
18016 arg4 = static_cast< wxEventType >(val4);
18017 }
18018 {
18019 PyThreadState* __tstate = wxPyBeginAllowThreads();
18020 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 {
18025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18026 }
18027 return resultobj;
18028 fail:
18029 return NULL;
18030 }
18031
18032
18033 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18034 PyObject *resultobj = 0;
18035 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18036 PyObject *arg2 = (PyObject *) 0 ;
18037 bool arg3 = (bool) true ;
18038 void *argp1 = 0 ;
18039 int res1 = 0 ;
18040 bool val3 ;
18041 int ecode3 = 0 ;
18042 PyObject * obj0 = 0 ;
18043 PyObject * obj1 = 0 ;
18044 PyObject * obj2 = 0 ;
18045 char * kwnames[] = {
18046 (char *) "self",(char *) "_self",(char *) "incref", NULL
18047 };
18048
18049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18051 if (!SWIG_IsOK(res1)) {
18052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18053 }
18054 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18055 arg2 = obj1;
18056 if (obj2) {
18057 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18058 if (!SWIG_IsOK(ecode3)) {
18059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18060 }
18061 arg3 = static_cast< bool >(val3);
18062 }
18063 {
18064 PyThreadState* __tstate = wxPyBeginAllowThreads();
18065 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18066 wxPyEndAllowThreads(__tstate);
18067 if (PyErr_Occurred()) SWIG_fail;
18068 }
18069 resultobj = SWIG_Py_Void();
18070 return resultobj;
18071 fail:
18072 return NULL;
18073 }
18074
18075
18076 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18077 PyObject *obj;
18078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18079 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18080 return SWIG_Py_Void();
18081 }
18082
18083 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18084 return SWIG_Python_InitShadowInstance(args);
18085 }
18086
18087 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18088 PyObject *resultobj = 0;
18089 wxEventType result;
18090
18091 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18092 {
18093 PyThreadState* __tstate = wxPyBeginAllowThreads();
18094 result = (wxEventType)wxNewEventType();
18095 wxPyEndAllowThreads(__tstate);
18096 if (PyErr_Occurred()) SWIG_fail;
18097 }
18098 resultobj = SWIG_From_int(static_cast< int >(result));
18099 return resultobj;
18100 fail:
18101 return NULL;
18102 }
18103
18104
18105 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18106 PyObject *resultobj = 0;
18107 wxEvent *arg1 = (wxEvent *) 0 ;
18108 void *argp1 = 0 ;
18109 int res1 = 0 ;
18110 PyObject *swig_obj[1] ;
18111
18112 if (!args) SWIG_fail;
18113 swig_obj[0] = args;
18114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18115 if (!SWIG_IsOK(res1)) {
18116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18117 }
18118 arg1 = reinterpret_cast< wxEvent * >(argp1);
18119 {
18120 PyThreadState* __tstate = wxPyBeginAllowThreads();
18121 delete arg1;
18122
18123 wxPyEndAllowThreads(__tstate);
18124 if (PyErr_Occurred()) SWIG_fail;
18125 }
18126 resultobj = SWIG_Py_Void();
18127 return resultobj;
18128 fail:
18129 return NULL;
18130 }
18131
18132
18133 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18134 PyObject *resultobj = 0;
18135 wxEvent *arg1 = (wxEvent *) 0 ;
18136 wxEventType arg2 ;
18137 void *argp1 = 0 ;
18138 int res1 = 0 ;
18139 int val2 ;
18140 int ecode2 = 0 ;
18141 PyObject * obj0 = 0 ;
18142 PyObject * obj1 = 0 ;
18143 char * kwnames[] = {
18144 (char *) "self",(char *) "typ", NULL
18145 };
18146
18147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18149 if (!SWIG_IsOK(res1)) {
18150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18151 }
18152 arg1 = reinterpret_cast< wxEvent * >(argp1);
18153 ecode2 = SWIG_AsVal_int(obj1, &val2);
18154 if (!SWIG_IsOK(ecode2)) {
18155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18156 }
18157 arg2 = static_cast< wxEventType >(val2);
18158 {
18159 PyThreadState* __tstate = wxPyBeginAllowThreads();
18160 (arg1)->SetEventType(arg2);
18161 wxPyEndAllowThreads(__tstate);
18162 if (PyErr_Occurred()) SWIG_fail;
18163 }
18164 resultobj = SWIG_Py_Void();
18165 return resultobj;
18166 fail:
18167 return NULL;
18168 }
18169
18170
18171 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18172 PyObject *resultobj = 0;
18173 wxEvent *arg1 = (wxEvent *) 0 ;
18174 wxEventType result;
18175 void *argp1 = 0 ;
18176 int res1 = 0 ;
18177 PyObject *swig_obj[1] ;
18178
18179 if (!args) SWIG_fail;
18180 swig_obj[0] = args;
18181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18182 if (!SWIG_IsOK(res1)) {
18183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18184 }
18185 arg1 = reinterpret_cast< wxEvent * >(argp1);
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18189 wxPyEndAllowThreads(__tstate);
18190 if (PyErr_Occurred()) SWIG_fail;
18191 }
18192 resultobj = SWIG_From_int(static_cast< int >(result));
18193 return resultobj;
18194 fail:
18195 return NULL;
18196 }
18197
18198
18199 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18200 PyObject *resultobj = 0;
18201 wxEvent *arg1 = (wxEvent *) 0 ;
18202 wxObject *result = 0 ;
18203 void *argp1 = 0 ;
18204 int res1 = 0 ;
18205 PyObject *swig_obj[1] ;
18206
18207 if (!args) SWIG_fail;
18208 swig_obj[0] = args;
18209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18210 if (!SWIG_IsOK(res1)) {
18211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18212 }
18213 arg1 = reinterpret_cast< wxEvent * >(argp1);
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18217 wxPyEndAllowThreads(__tstate);
18218 if (PyErr_Occurred()) SWIG_fail;
18219 }
18220 {
18221 resultobj = wxPyMake_wxObject(result, (bool)0);
18222 }
18223 return resultobj;
18224 fail:
18225 return NULL;
18226 }
18227
18228
18229 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18230 PyObject *resultobj = 0;
18231 wxEvent *arg1 = (wxEvent *) 0 ;
18232 wxObject *arg2 = (wxObject *) 0 ;
18233 void *argp1 = 0 ;
18234 int res1 = 0 ;
18235 void *argp2 = 0 ;
18236 int res2 = 0 ;
18237 PyObject * obj0 = 0 ;
18238 PyObject * obj1 = 0 ;
18239 char * kwnames[] = {
18240 (char *) "self",(char *) "obj", NULL
18241 };
18242
18243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18245 if (!SWIG_IsOK(res1)) {
18246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18247 }
18248 arg1 = reinterpret_cast< wxEvent * >(argp1);
18249 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18250 if (!SWIG_IsOK(res2)) {
18251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18252 }
18253 arg2 = reinterpret_cast< wxObject * >(argp2);
18254 {
18255 PyThreadState* __tstate = wxPyBeginAllowThreads();
18256 (arg1)->SetEventObject(arg2);
18257 wxPyEndAllowThreads(__tstate);
18258 if (PyErr_Occurred()) SWIG_fail;
18259 }
18260 resultobj = SWIG_Py_Void();
18261 return resultobj;
18262 fail:
18263 return NULL;
18264 }
18265
18266
18267 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18268 PyObject *resultobj = 0;
18269 wxEvent *arg1 = (wxEvent *) 0 ;
18270 long result;
18271 void *argp1 = 0 ;
18272 int res1 = 0 ;
18273 PyObject *swig_obj[1] ;
18274
18275 if (!args) SWIG_fail;
18276 swig_obj[0] = args;
18277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18278 if (!SWIG_IsOK(res1)) {
18279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18280 }
18281 arg1 = reinterpret_cast< wxEvent * >(argp1);
18282 {
18283 PyThreadState* __tstate = wxPyBeginAllowThreads();
18284 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18285 wxPyEndAllowThreads(__tstate);
18286 if (PyErr_Occurred()) SWIG_fail;
18287 }
18288 resultobj = SWIG_From_long(static_cast< long >(result));
18289 return resultobj;
18290 fail:
18291 return NULL;
18292 }
18293
18294
18295 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18296 PyObject *resultobj = 0;
18297 wxEvent *arg1 = (wxEvent *) 0 ;
18298 long arg2 = (long) 0 ;
18299 void *argp1 = 0 ;
18300 int res1 = 0 ;
18301 long val2 ;
18302 int ecode2 = 0 ;
18303 PyObject * obj0 = 0 ;
18304 PyObject * obj1 = 0 ;
18305 char * kwnames[] = {
18306 (char *) "self",(char *) "ts", NULL
18307 };
18308
18309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18311 if (!SWIG_IsOK(res1)) {
18312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18313 }
18314 arg1 = reinterpret_cast< wxEvent * >(argp1);
18315 if (obj1) {
18316 ecode2 = SWIG_AsVal_long(obj1, &val2);
18317 if (!SWIG_IsOK(ecode2)) {
18318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18319 }
18320 arg2 = static_cast< long >(val2);
18321 }
18322 {
18323 PyThreadState* __tstate = wxPyBeginAllowThreads();
18324 (arg1)->SetTimestamp(arg2);
18325 wxPyEndAllowThreads(__tstate);
18326 if (PyErr_Occurred()) SWIG_fail;
18327 }
18328 resultobj = SWIG_Py_Void();
18329 return resultobj;
18330 fail:
18331 return NULL;
18332 }
18333
18334
18335 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18336 PyObject *resultobj = 0;
18337 wxEvent *arg1 = (wxEvent *) 0 ;
18338 int result;
18339 void *argp1 = 0 ;
18340 int res1 = 0 ;
18341 PyObject *swig_obj[1] ;
18342
18343 if (!args) SWIG_fail;
18344 swig_obj[0] = args;
18345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18346 if (!SWIG_IsOK(res1)) {
18347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18348 }
18349 arg1 = reinterpret_cast< wxEvent * >(argp1);
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 result = (int)((wxEvent const *)arg1)->GetId();
18353 wxPyEndAllowThreads(__tstate);
18354 if (PyErr_Occurred()) SWIG_fail;
18355 }
18356 resultobj = SWIG_From_int(static_cast< int >(result));
18357 return resultobj;
18358 fail:
18359 return NULL;
18360 }
18361
18362
18363 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18364 PyObject *resultobj = 0;
18365 wxEvent *arg1 = (wxEvent *) 0 ;
18366 int arg2 ;
18367 void *argp1 = 0 ;
18368 int res1 = 0 ;
18369 int val2 ;
18370 int ecode2 = 0 ;
18371 PyObject * obj0 = 0 ;
18372 PyObject * obj1 = 0 ;
18373 char * kwnames[] = {
18374 (char *) "self",(char *) "Id", NULL
18375 };
18376
18377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18379 if (!SWIG_IsOK(res1)) {
18380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18381 }
18382 arg1 = reinterpret_cast< wxEvent * >(argp1);
18383 ecode2 = SWIG_AsVal_int(obj1, &val2);
18384 if (!SWIG_IsOK(ecode2)) {
18385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18386 }
18387 arg2 = static_cast< int >(val2);
18388 {
18389 PyThreadState* __tstate = wxPyBeginAllowThreads();
18390 (arg1)->SetId(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_IsCommandEvent(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_IsCommandEvent" "', 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)->IsCommandEvent();
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_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18432 PyObject *resultobj = 0;
18433 wxEvent *arg1 = (wxEvent *) 0 ;
18434 bool arg2 = (bool) true ;
18435 void *argp1 = 0 ;
18436 int res1 = 0 ;
18437 bool val2 ;
18438 int ecode2 = 0 ;
18439 PyObject * obj0 = 0 ;
18440 PyObject * obj1 = 0 ;
18441 char * kwnames[] = {
18442 (char *) "self",(char *) "skip", NULL
18443 };
18444
18445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18447 if (!SWIG_IsOK(res1)) {
18448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18449 }
18450 arg1 = reinterpret_cast< wxEvent * >(argp1);
18451 if (obj1) {
18452 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18453 if (!SWIG_IsOK(ecode2)) {
18454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18455 }
18456 arg2 = static_cast< bool >(val2);
18457 }
18458 {
18459 PyThreadState* __tstate = wxPyBeginAllowThreads();
18460 (arg1)->Skip(arg2);
18461 wxPyEndAllowThreads(__tstate);
18462 if (PyErr_Occurred()) SWIG_fail;
18463 }
18464 resultobj = SWIG_Py_Void();
18465 return resultobj;
18466 fail:
18467 return NULL;
18468 }
18469
18470
18471 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18472 PyObject *resultobj = 0;
18473 wxEvent *arg1 = (wxEvent *) 0 ;
18474 bool result;
18475 void *argp1 = 0 ;
18476 int res1 = 0 ;
18477 PyObject *swig_obj[1] ;
18478
18479 if (!args) SWIG_fail;
18480 swig_obj[0] = args;
18481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18482 if (!SWIG_IsOK(res1)) {
18483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18484 }
18485 arg1 = reinterpret_cast< wxEvent * >(argp1);
18486 {
18487 PyThreadState* __tstate = wxPyBeginAllowThreads();
18488 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18489 wxPyEndAllowThreads(__tstate);
18490 if (PyErr_Occurred()) SWIG_fail;
18491 }
18492 {
18493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18494 }
18495 return resultobj;
18496 fail:
18497 return NULL;
18498 }
18499
18500
18501 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18502 PyObject *resultobj = 0;
18503 wxEvent *arg1 = (wxEvent *) 0 ;
18504 bool result;
18505 void *argp1 = 0 ;
18506 int res1 = 0 ;
18507 PyObject *swig_obj[1] ;
18508
18509 if (!args) SWIG_fail;
18510 swig_obj[0] = args;
18511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18512 if (!SWIG_IsOK(res1)) {
18513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18514 }
18515 arg1 = reinterpret_cast< wxEvent * >(argp1);
18516 {
18517 PyThreadState* __tstate = wxPyBeginAllowThreads();
18518 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18519 wxPyEndAllowThreads(__tstate);
18520 if (PyErr_Occurred()) SWIG_fail;
18521 }
18522 {
18523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18524 }
18525 return resultobj;
18526 fail:
18527 return NULL;
18528 }
18529
18530
18531 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18532 PyObject *resultobj = 0;
18533 wxEvent *arg1 = (wxEvent *) 0 ;
18534 int result;
18535 void *argp1 = 0 ;
18536 int res1 = 0 ;
18537 PyObject *swig_obj[1] ;
18538
18539 if (!args) SWIG_fail;
18540 swig_obj[0] = args;
18541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18542 if (!SWIG_IsOK(res1)) {
18543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18544 }
18545 arg1 = reinterpret_cast< wxEvent * >(argp1);
18546 {
18547 PyThreadState* __tstate = wxPyBeginAllowThreads();
18548 result = (int)(arg1)->StopPropagation();
18549 wxPyEndAllowThreads(__tstate);
18550 if (PyErr_Occurred()) SWIG_fail;
18551 }
18552 resultobj = SWIG_From_int(static_cast< int >(result));
18553 return resultobj;
18554 fail:
18555 return NULL;
18556 }
18557
18558
18559 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18560 PyObject *resultobj = 0;
18561 wxEvent *arg1 = (wxEvent *) 0 ;
18562 int arg2 ;
18563 void *argp1 = 0 ;
18564 int res1 = 0 ;
18565 int val2 ;
18566 int ecode2 = 0 ;
18567 PyObject * obj0 = 0 ;
18568 PyObject * obj1 = 0 ;
18569 char * kwnames[] = {
18570 (char *) "self",(char *) "propagationLevel", NULL
18571 };
18572
18573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18575 if (!SWIG_IsOK(res1)) {
18576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18577 }
18578 arg1 = reinterpret_cast< wxEvent * >(argp1);
18579 ecode2 = SWIG_AsVal_int(obj1, &val2);
18580 if (!SWIG_IsOK(ecode2)) {
18581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18582 }
18583 arg2 = static_cast< int >(val2);
18584 {
18585 PyThreadState* __tstate = wxPyBeginAllowThreads();
18586 (arg1)->ResumePropagation(arg2);
18587 wxPyEndAllowThreads(__tstate);
18588 if (PyErr_Occurred()) SWIG_fail;
18589 }
18590 resultobj = SWIG_Py_Void();
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18598 PyObject *resultobj = 0;
18599 wxEvent *arg1 = (wxEvent *) 0 ;
18600 wxEvent *result = 0 ;
18601 void *argp1 = 0 ;
18602 int res1 = 0 ;
18603 PyObject *swig_obj[1] ;
18604
18605 if (!args) SWIG_fail;
18606 swig_obj[0] = args;
18607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18608 if (!SWIG_IsOK(res1)) {
18609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18610 }
18611 arg1 = reinterpret_cast< wxEvent * >(argp1);
18612 {
18613 PyThreadState* __tstate = wxPyBeginAllowThreads();
18614 result = (wxEvent *)(arg1)->Clone();
18615 wxPyEndAllowThreads(__tstate);
18616 if (PyErr_Occurred()) SWIG_fail;
18617 }
18618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18619 return resultobj;
18620 fail:
18621 return NULL;
18622 }
18623
18624
18625 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18626 PyObject *obj;
18627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18628 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18629 return SWIG_Py_Void();
18630 }
18631
18632 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18633 PyObject *resultobj = 0;
18634 wxEvent *arg1 = 0 ;
18635 wxPropagationDisabler *result = 0 ;
18636 void *argp1 = 0 ;
18637 int res1 = 0 ;
18638 PyObject * obj0 = 0 ;
18639 char * kwnames[] = {
18640 (char *) "event", NULL
18641 };
18642
18643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18644 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18645 if (!SWIG_IsOK(res1)) {
18646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18647 }
18648 if (!argp1) {
18649 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18650 }
18651 arg1 = reinterpret_cast< wxEvent * >(argp1);
18652 {
18653 PyThreadState* __tstate = wxPyBeginAllowThreads();
18654 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18655 wxPyEndAllowThreads(__tstate);
18656 if (PyErr_Occurred()) SWIG_fail;
18657 }
18658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18659 return resultobj;
18660 fail:
18661 return NULL;
18662 }
18663
18664
18665 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18666 PyObject *resultobj = 0;
18667 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18668 void *argp1 = 0 ;
18669 int res1 = 0 ;
18670 PyObject *swig_obj[1] ;
18671
18672 if (!args) SWIG_fail;
18673 swig_obj[0] = args;
18674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18675 if (!SWIG_IsOK(res1)) {
18676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18677 }
18678 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18679 {
18680 PyThreadState* __tstate = wxPyBeginAllowThreads();
18681 delete arg1;
18682
18683 wxPyEndAllowThreads(__tstate);
18684 if (PyErr_Occurred()) SWIG_fail;
18685 }
18686 resultobj = SWIG_Py_Void();
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18694 PyObject *obj;
18695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18696 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18697 return SWIG_Py_Void();
18698 }
18699
18700 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18701 return SWIG_Python_InitShadowInstance(args);
18702 }
18703
18704 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18705 PyObject *resultobj = 0;
18706 wxEvent *arg1 = 0 ;
18707 wxPropagateOnce *result = 0 ;
18708 void *argp1 = 0 ;
18709 int res1 = 0 ;
18710 PyObject * obj0 = 0 ;
18711 char * kwnames[] = {
18712 (char *) "event", NULL
18713 };
18714
18715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18716 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18717 if (!SWIG_IsOK(res1)) {
18718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18719 }
18720 if (!argp1) {
18721 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18722 }
18723 arg1 = reinterpret_cast< wxEvent * >(argp1);
18724 {
18725 PyThreadState* __tstate = wxPyBeginAllowThreads();
18726 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18727 wxPyEndAllowThreads(__tstate);
18728 if (PyErr_Occurred()) SWIG_fail;
18729 }
18730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18731 return resultobj;
18732 fail:
18733 return NULL;
18734 }
18735
18736
18737 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18738 PyObject *resultobj = 0;
18739 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18740 void *argp1 = 0 ;
18741 int res1 = 0 ;
18742 PyObject *swig_obj[1] ;
18743
18744 if (!args) SWIG_fail;
18745 swig_obj[0] = args;
18746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18747 if (!SWIG_IsOK(res1)) {
18748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18749 }
18750 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18751 {
18752 PyThreadState* __tstate = wxPyBeginAllowThreads();
18753 delete arg1;
18754
18755 wxPyEndAllowThreads(__tstate);
18756 if (PyErr_Occurred()) SWIG_fail;
18757 }
18758 resultobj = SWIG_Py_Void();
18759 return resultobj;
18760 fail:
18761 return NULL;
18762 }
18763
18764
18765 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18766 PyObject *obj;
18767 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18768 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18769 return SWIG_Py_Void();
18770 }
18771
18772 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18773 return SWIG_Python_InitShadowInstance(args);
18774 }
18775
18776 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18777 PyObject *resultobj = 0;
18778 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18779 int arg2 = (int) 0 ;
18780 wxCommandEvent *result = 0 ;
18781 int val1 ;
18782 int ecode1 = 0 ;
18783 int val2 ;
18784 int ecode2 = 0 ;
18785 PyObject * obj0 = 0 ;
18786 PyObject * obj1 = 0 ;
18787 char * kwnames[] = {
18788 (char *) "commandType",(char *) "winid", NULL
18789 };
18790
18791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18792 if (obj0) {
18793 ecode1 = SWIG_AsVal_int(obj0, &val1);
18794 if (!SWIG_IsOK(ecode1)) {
18795 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18796 }
18797 arg1 = static_cast< wxEventType >(val1);
18798 }
18799 if (obj1) {
18800 ecode2 = SWIG_AsVal_int(obj1, &val2);
18801 if (!SWIG_IsOK(ecode2)) {
18802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18803 }
18804 arg2 = static_cast< int >(val2);
18805 }
18806 {
18807 PyThreadState* __tstate = wxPyBeginAllowThreads();
18808 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18809 wxPyEndAllowThreads(__tstate);
18810 if (PyErr_Occurred()) SWIG_fail;
18811 }
18812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18813 return resultobj;
18814 fail:
18815 return NULL;
18816 }
18817
18818
18819 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18820 PyObject *resultobj = 0;
18821 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18822 int result;
18823 void *argp1 = 0 ;
18824 int res1 = 0 ;
18825 PyObject *swig_obj[1] ;
18826
18827 if (!args) SWIG_fail;
18828 swig_obj[0] = args;
18829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18830 if (!SWIG_IsOK(res1)) {
18831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18832 }
18833 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18834 {
18835 PyThreadState* __tstate = wxPyBeginAllowThreads();
18836 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18837 wxPyEndAllowThreads(__tstate);
18838 if (PyErr_Occurred()) SWIG_fail;
18839 }
18840 resultobj = SWIG_From_int(static_cast< int >(result));
18841 return resultobj;
18842 fail:
18843 return NULL;
18844 }
18845
18846
18847 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18848 PyObject *resultobj = 0;
18849 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18850 wxString *arg2 = 0 ;
18851 void *argp1 = 0 ;
18852 int res1 = 0 ;
18853 bool temp2 = false ;
18854 PyObject * obj0 = 0 ;
18855 PyObject * obj1 = 0 ;
18856 char * kwnames[] = {
18857 (char *) "self",(char *) "s", NULL
18858 };
18859
18860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18862 if (!SWIG_IsOK(res1)) {
18863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18864 }
18865 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18866 {
18867 arg2 = wxString_in_helper(obj1);
18868 if (arg2 == NULL) SWIG_fail;
18869 temp2 = true;
18870 }
18871 {
18872 PyThreadState* __tstate = wxPyBeginAllowThreads();
18873 (arg1)->SetString((wxString const &)*arg2);
18874 wxPyEndAllowThreads(__tstate);
18875 if (PyErr_Occurred()) SWIG_fail;
18876 }
18877 resultobj = SWIG_Py_Void();
18878 {
18879 if (temp2)
18880 delete arg2;
18881 }
18882 return resultobj;
18883 fail:
18884 {
18885 if (temp2)
18886 delete arg2;
18887 }
18888 return NULL;
18889 }
18890
18891
18892 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18893 PyObject *resultobj = 0;
18894 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18895 wxString result;
18896 void *argp1 = 0 ;
18897 int res1 = 0 ;
18898 PyObject *swig_obj[1] ;
18899
18900 if (!args) SWIG_fail;
18901 swig_obj[0] = args;
18902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18903 if (!SWIG_IsOK(res1)) {
18904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18905 }
18906 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18907 {
18908 PyThreadState* __tstate = wxPyBeginAllowThreads();
18909 result = ((wxCommandEvent const *)arg1)->GetString();
18910 wxPyEndAllowThreads(__tstate);
18911 if (PyErr_Occurred()) SWIG_fail;
18912 }
18913 {
18914 #if wxUSE_UNICODE
18915 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18916 #else
18917 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18918 #endif
18919 }
18920 return resultobj;
18921 fail:
18922 return NULL;
18923 }
18924
18925
18926 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18927 PyObject *resultobj = 0;
18928 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18929 bool result;
18930 void *argp1 = 0 ;
18931 int res1 = 0 ;
18932 PyObject *swig_obj[1] ;
18933
18934 if (!args) SWIG_fail;
18935 swig_obj[0] = args;
18936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18937 if (!SWIG_IsOK(res1)) {
18938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18939 }
18940 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18941 {
18942 PyThreadState* __tstate = wxPyBeginAllowThreads();
18943 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18944 wxPyEndAllowThreads(__tstate);
18945 if (PyErr_Occurred()) SWIG_fail;
18946 }
18947 {
18948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18949 }
18950 return resultobj;
18951 fail:
18952 return NULL;
18953 }
18954
18955
18956 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18957 PyObject *resultobj = 0;
18958 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18959 bool result;
18960 void *argp1 = 0 ;
18961 int res1 = 0 ;
18962 PyObject *swig_obj[1] ;
18963
18964 if (!args) SWIG_fail;
18965 swig_obj[0] = args;
18966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18967 if (!SWIG_IsOK(res1)) {
18968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18969 }
18970 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18971 {
18972 PyThreadState* __tstate = wxPyBeginAllowThreads();
18973 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18974 wxPyEndAllowThreads(__tstate);
18975 if (PyErr_Occurred()) SWIG_fail;
18976 }
18977 {
18978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18979 }
18980 return resultobj;
18981 fail:
18982 return NULL;
18983 }
18984
18985
18986 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18987 PyObject *resultobj = 0;
18988 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18989 long arg2 ;
18990 void *argp1 = 0 ;
18991 int res1 = 0 ;
18992 long val2 ;
18993 int ecode2 = 0 ;
18994 PyObject * obj0 = 0 ;
18995 PyObject * obj1 = 0 ;
18996 char * kwnames[] = {
18997 (char *) "self",(char *) "extraLong", NULL
18998 };
18999
19000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19002 if (!SWIG_IsOK(res1)) {
19003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19004 }
19005 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19006 ecode2 = SWIG_AsVal_long(obj1, &val2);
19007 if (!SWIG_IsOK(ecode2)) {
19008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19009 }
19010 arg2 = static_cast< long >(val2);
19011 {
19012 PyThreadState* __tstate = wxPyBeginAllowThreads();
19013 (arg1)->SetExtraLong(arg2);
19014 wxPyEndAllowThreads(__tstate);
19015 if (PyErr_Occurred()) SWIG_fail;
19016 }
19017 resultobj = SWIG_Py_Void();
19018 return resultobj;
19019 fail:
19020 return NULL;
19021 }
19022
19023
19024 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19025 PyObject *resultobj = 0;
19026 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19027 long result;
19028 void *argp1 = 0 ;
19029 int res1 = 0 ;
19030 PyObject *swig_obj[1] ;
19031
19032 if (!args) SWIG_fail;
19033 swig_obj[0] = args;
19034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19035 if (!SWIG_IsOK(res1)) {
19036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19037 }
19038 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19039 {
19040 PyThreadState* __tstate = wxPyBeginAllowThreads();
19041 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19042 wxPyEndAllowThreads(__tstate);
19043 if (PyErr_Occurred()) SWIG_fail;
19044 }
19045 resultobj = SWIG_From_long(static_cast< long >(result));
19046 return resultobj;
19047 fail:
19048 return NULL;
19049 }
19050
19051
19052 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19053 PyObject *resultobj = 0;
19054 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19055 int arg2 ;
19056 void *argp1 = 0 ;
19057 int res1 = 0 ;
19058 int val2 ;
19059 int ecode2 = 0 ;
19060 PyObject * obj0 = 0 ;
19061 PyObject * obj1 = 0 ;
19062 char * kwnames[] = {
19063 (char *) "self",(char *) "i", NULL
19064 };
19065
19066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19068 if (!SWIG_IsOK(res1)) {
19069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19070 }
19071 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19072 ecode2 = SWIG_AsVal_int(obj1, &val2);
19073 if (!SWIG_IsOK(ecode2)) {
19074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19075 }
19076 arg2 = static_cast< int >(val2);
19077 {
19078 PyThreadState* __tstate = wxPyBeginAllowThreads();
19079 (arg1)->SetInt(arg2);
19080 wxPyEndAllowThreads(__tstate);
19081 if (PyErr_Occurred()) SWIG_fail;
19082 }
19083 resultobj = SWIG_Py_Void();
19084 return resultobj;
19085 fail:
19086 return NULL;
19087 }
19088
19089
19090 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19091 PyObject *resultobj = 0;
19092 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19093 int result;
19094 void *argp1 = 0 ;
19095 int res1 = 0 ;
19096 PyObject *swig_obj[1] ;
19097
19098 if (!args) SWIG_fail;
19099 swig_obj[0] = args;
19100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19101 if (!SWIG_IsOK(res1)) {
19102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19103 }
19104 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19105 {
19106 PyThreadState* __tstate = wxPyBeginAllowThreads();
19107 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19108 wxPyEndAllowThreads(__tstate);
19109 if (PyErr_Occurred()) SWIG_fail;
19110 }
19111 resultobj = SWIG_From_int(static_cast< int >(result));
19112 return resultobj;
19113 fail:
19114 return NULL;
19115 }
19116
19117
19118 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19119 PyObject *resultobj = 0;
19120 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19121 PyObject *result = 0 ;
19122 void *argp1 = 0 ;
19123 int res1 = 0 ;
19124 PyObject *swig_obj[1] ;
19125
19126 if (!args) SWIG_fail;
19127 swig_obj[0] = args;
19128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19129 if (!SWIG_IsOK(res1)) {
19130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19131 }
19132 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19133 {
19134 PyThreadState* __tstate = wxPyBeginAllowThreads();
19135 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19136 wxPyEndAllowThreads(__tstate);
19137 if (PyErr_Occurred()) SWIG_fail;
19138 }
19139 resultobj = result;
19140 return resultobj;
19141 fail:
19142 return NULL;
19143 }
19144
19145
19146 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19147 PyObject *resultobj = 0;
19148 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19149 PyObject *arg2 = (PyObject *) 0 ;
19150 void *argp1 = 0 ;
19151 int res1 = 0 ;
19152 PyObject * obj0 = 0 ;
19153 PyObject * obj1 = 0 ;
19154 char * kwnames[] = {
19155 (char *) "self",(char *) "clientData", NULL
19156 };
19157
19158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19160 if (!SWIG_IsOK(res1)) {
19161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19162 }
19163 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19164 arg2 = obj1;
19165 {
19166 PyThreadState* __tstate = wxPyBeginAllowThreads();
19167 wxCommandEvent_SetClientData(arg1,arg2);
19168 wxPyEndAllowThreads(__tstate);
19169 if (PyErr_Occurred()) SWIG_fail;
19170 }
19171 resultobj = SWIG_Py_Void();
19172 return resultobj;
19173 fail:
19174 return NULL;
19175 }
19176
19177
19178 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19179 PyObject *resultobj = 0;
19180 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19181 wxEvent *result = 0 ;
19182 void *argp1 = 0 ;
19183 int res1 = 0 ;
19184 PyObject *swig_obj[1] ;
19185
19186 if (!args) SWIG_fail;
19187 swig_obj[0] = args;
19188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19189 if (!SWIG_IsOK(res1)) {
19190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19191 }
19192 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19193 {
19194 PyThreadState* __tstate = wxPyBeginAllowThreads();
19195 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19196 wxPyEndAllowThreads(__tstate);
19197 if (PyErr_Occurred()) SWIG_fail;
19198 }
19199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19200 return resultobj;
19201 fail:
19202 return NULL;
19203 }
19204
19205
19206 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19207 PyObject *obj;
19208 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19209 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19210 return SWIG_Py_Void();
19211 }
19212
19213 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19214 return SWIG_Python_InitShadowInstance(args);
19215 }
19216
19217 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19218 PyObject *resultobj = 0;
19219 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19220 int arg2 = (int) 0 ;
19221 wxNotifyEvent *result = 0 ;
19222 int val1 ;
19223 int ecode1 = 0 ;
19224 int val2 ;
19225 int ecode2 = 0 ;
19226 PyObject * obj0 = 0 ;
19227 PyObject * obj1 = 0 ;
19228 char * kwnames[] = {
19229 (char *) "commandType",(char *) "winid", NULL
19230 };
19231
19232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19233 if (obj0) {
19234 ecode1 = SWIG_AsVal_int(obj0, &val1);
19235 if (!SWIG_IsOK(ecode1)) {
19236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19237 }
19238 arg1 = static_cast< wxEventType >(val1);
19239 }
19240 if (obj1) {
19241 ecode2 = SWIG_AsVal_int(obj1, &val2);
19242 if (!SWIG_IsOK(ecode2)) {
19243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19244 }
19245 arg2 = static_cast< int >(val2);
19246 }
19247 {
19248 PyThreadState* __tstate = wxPyBeginAllowThreads();
19249 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19250 wxPyEndAllowThreads(__tstate);
19251 if (PyErr_Occurred()) SWIG_fail;
19252 }
19253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19254 return resultobj;
19255 fail:
19256 return NULL;
19257 }
19258
19259
19260 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19261 PyObject *resultobj = 0;
19262 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19263 void *argp1 = 0 ;
19264 int res1 = 0 ;
19265 PyObject *swig_obj[1] ;
19266
19267 if (!args) SWIG_fail;
19268 swig_obj[0] = args;
19269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19270 if (!SWIG_IsOK(res1)) {
19271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19272 }
19273 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19274 {
19275 PyThreadState* __tstate = wxPyBeginAllowThreads();
19276 (arg1)->Veto();
19277 wxPyEndAllowThreads(__tstate);
19278 if (PyErr_Occurred()) SWIG_fail;
19279 }
19280 resultobj = SWIG_Py_Void();
19281 return resultobj;
19282 fail:
19283 return NULL;
19284 }
19285
19286
19287 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19288 PyObject *resultobj = 0;
19289 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19290 void *argp1 = 0 ;
19291 int res1 = 0 ;
19292 PyObject *swig_obj[1] ;
19293
19294 if (!args) SWIG_fail;
19295 swig_obj[0] = args;
19296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19297 if (!SWIG_IsOK(res1)) {
19298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19299 }
19300 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19301 {
19302 PyThreadState* __tstate = wxPyBeginAllowThreads();
19303 (arg1)->Allow();
19304 wxPyEndAllowThreads(__tstate);
19305 if (PyErr_Occurred()) SWIG_fail;
19306 }
19307 resultobj = SWIG_Py_Void();
19308 return resultobj;
19309 fail:
19310 return NULL;
19311 }
19312
19313
19314 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19315 PyObject *resultobj = 0;
19316 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19317 bool result;
19318 void *argp1 = 0 ;
19319 int res1 = 0 ;
19320 PyObject *swig_obj[1] ;
19321
19322 if (!args) SWIG_fail;
19323 swig_obj[0] = args;
19324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19325 if (!SWIG_IsOK(res1)) {
19326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19327 }
19328 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19329 {
19330 PyThreadState* __tstate = wxPyBeginAllowThreads();
19331 result = (bool)(arg1)->IsAllowed();
19332 wxPyEndAllowThreads(__tstate);
19333 if (PyErr_Occurred()) SWIG_fail;
19334 }
19335 {
19336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19337 }
19338 return resultobj;
19339 fail:
19340 return NULL;
19341 }
19342
19343
19344 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19345 PyObject *obj;
19346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19347 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19348 return SWIG_Py_Void();
19349 }
19350
19351 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19352 return SWIG_Python_InitShadowInstance(args);
19353 }
19354
19355 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19356 PyObject *resultobj = 0;
19357 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19358 int arg2 = (int) 0 ;
19359 int arg3 = (int) 0 ;
19360 int arg4 = (int) 0 ;
19361 wxScrollEvent *result = 0 ;
19362 int val1 ;
19363 int ecode1 = 0 ;
19364 int val2 ;
19365 int ecode2 = 0 ;
19366 int val3 ;
19367 int ecode3 = 0 ;
19368 int val4 ;
19369 int ecode4 = 0 ;
19370 PyObject * obj0 = 0 ;
19371 PyObject * obj1 = 0 ;
19372 PyObject * obj2 = 0 ;
19373 PyObject * obj3 = 0 ;
19374 char * kwnames[] = {
19375 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19376 };
19377
19378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19379 if (obj0) {
19380 ecode1 = SWIG_AsVal_int(obj0, &val1);
19381 if (!SWIG_IsOK(ecode1)) {
19382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19383 }
19384 arg1 = static_cast< wxEventType >(val1);
19385 }
19386 if (obj1) {
19387 ecode2 = SWIG_AsVal_int(obj1, &val2);
19388 if (!SWIG_IsOK(ecode2)) {
19389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19390 }
19391 arg2 = static_cast< int >(val2);
19392 }
19393 if (obj2) {
19394 ecode3 = SWIG_AsVal_int(obj2, &val3);
19395 if (!SWIG_IsOK(ecode3)) {
19396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19397 }
19398 arg3 = static_cast< int >(val3);
19399 }
19400 if (obj3) {
19401 ecode4 = SWIG_AsVal_int(obj3, &val4);
19402 if (!SWIG_IsOK(ecode4)) {
19403 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19404 }
19405 arg4 = static_cast< int >(val4);
19406 }
19407 {
19408 PyThreadState* __tstate = wxPyBeginAllowThreads();
19409 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19410 wxPyEndAllowThreads(__tstate);
19411 if (PyErr_Occurred()) SWIG_fail;
19412 }
19413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19414 return resultobj;
19415 fail:
19416 return NULL;
19417 }
19418
19419
19420 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19421 PyObject *resultobj = 0;
19422 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19423 int result;
19424 void *argp1 = 0 ;
19425 int res1 = 0 ;
19426 PyObject *swig_obj[1] ;
19427
19428 if (!args) SWIG_fail;
19429 swig_obj[0] = args;
19430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19431 if (!SWIG_IsOK(res1)) {
19432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19433 }
19434 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19435 {
19436 PyThreadState* __tstate = wxPyBeginAllowThreads();
19437 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19438 wxPyEndAllowThreads(__tstate);
19439 if (PyErr_Occurred()) SWIG_fail;
19440 }
19441 resultobj = SWIG_From_int(static_cast< int >(result));
19442 return resultobj;
19443 fail:
19444 return NULL;
19445 }
19446
19447
19448 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19449 PyObject *resultobj = 0;
19450 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19451 int result;
19452 void *argp1 = 0 ;
19453 int res1 = 0 ;
19454 PyObject *swig_obj[1] ;
19455
19456 if (!args) SWIG_fail;
19457 swig_obj[0] = args;
19458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19459 if (!SWIG_IsOK(res1)) {
19460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19461 }
19462 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19463 {
19464 PyThreadState* __tstate = wxPyBeginAllowThreads();
19465 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 resultobj = SWIG_From_int(static_cast< int >(result));
19470 return resultobj;
19471 fail:
19472 return NULL;
19473 }
19474
19475
19476 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19477 PyObject *resultobj = 0;
19478 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19479 int arg2 ;
19480 void *argp1 = 0 ;
19481 int res1 = 0 ;
19482 int val2 ;
19483 int ecode2 = 0 ;
19484 PyObject * obj0 = 0 ;
19485 PyObject * obj1 = 0 ;
19486 char * kwnames[] = {
19487 (char *) "self",(char *) "orient", NULL
19488 };
19489
19490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19492 if (!SWIG_IsOK(res1)) {
19493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19494 }
19495 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19496 ecode2 = SWIG_AsVal_int(obj1, &val2);
19497 if (!SWIG_IsOK(ecode2)) {
19498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19499 }
19500 arg2 = static_cast< int >(val2);
19501 {
19502 PyThreadState* __tstate = wxPyBeginAllowThreads();
19503 (arg1)->SetOrientation(arg2);
19504 wxPyEndAllowThreads(__tstate);
19505 if (PyErr_Occurred()) SWIG_fail;
19506 }
19507 resultobj = SWIG_Py_Void();
19508 return resultobj;
19509 fail:
19510 return NULL;
19511 }
19512
19513
19514 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19515 PyObject *resultobj = 0;
19516 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19517 int arg2 ;
19518 void *argp1 = 0 ;
19519 int res1 = 0 ;
19520 int val2 ;
19521 int ecode2 = 0 ;
19522 PyObject * obj0 = 0 ;
19523 PyObject * obj1 = 0 ;
19524 char * kwnames[] = {
19525 (char *) "self",(char *) "pos", NULL
19526 };
19527
19528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19530 if (!SWIG_IsOK(res1)) {
19531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19532 }
19533 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19534 ecode2 = SWIG_AsVal_int(obj1, &val2);
19535 if (!SWIG_IsOK(ecode2)) {
19536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19537 }
19538 arg2 = static_cast< int >(val2);
19539 {
19540 PyThreadState* __tstate = wxPyBeginAllowThreads();
19541 (arg1)->SetPosition(arg2);
19542 wxPyEndAllowThreads(__tstate);
19543 if (PyErr_Occurred()) SWIG_fail;
19544 }
19545 resultobj = SWIG_Py_Void();
19546 return resultobj;
19547 fail:
19548 return NULL;
19549 }
19550
19551
19552 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19553 PyObject *obj;
19554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19555 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19556 return SWIG_Py_Void();
19557 }
19558
19559 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19560 return SWIG_Python_InitShadowInstance(args);
19561 }
19562
19563 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19564 PyObject *resultobj = 0;
19565 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19566 int arg2 = (int) 0 ;
19567 int arg3 = (int) 0 ;
19568 wxScrollWinEvent *result = 0 ;
19569 int val1 ;
19570 int ecode1 = 0 ;
19571 int val2 ;
19572 int ecode2 = 0 ;
19573 int val3 ;
19574 int ecode3 = 0 ;
19575 PyObject * obj0 = 0 ;
19576 PyObject * obj1 = 0 ;
19577 PyObject * obj2 = 0 ;
19578 char * kwnames[] = {
19579 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19580 };
19581
19582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19583 if (obj0) {
19584 ecode1 = SWIG_AsVal_int(obj0, &val1);
19585 if (!SWIG_IsOK(ecode1)) {
19586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19587 }
19588 arg1 = static_cast< wxEventType >(val1);
19589 }
19590 if (obj1) {
19591 ecode2 = SWIG_AsVal_int(obj1, &val2);
19592 if (!SWIG_IsOK(ecode2)) {
19593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19594 }
19595 arg2 = static_cast< int >(val2);
19596 }
19597 if (obj2) {
19598 ecode3 = SWIG_AsVal_int(obj2, &val3);
19599 if (!SWIG_IsOK(ecode3)) {
19600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19601 }
19602 arg3 = static_cast< int >(val3);
19603 }
19604 {
19605 PyThreadState* __tstate = wxPyBeginAllowThreads();
19606 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19607 wxPyEndAllowThreads(__tstate);
19608 if (PyErr_Occurred()) SWIG_fail;
19609 }
19610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19611 return resultobj;
19612 fail:
19613 return NULL;
19614 }
19615
19616
19617 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19618 PyObject *resultobj = 0;
19619 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19620 int result;
19621 void *argp1 = 0 ;
19622 int res1 = 0 ;
19623 PyObject *swig_obj[1] ;
19624
19625 if (!args) SWIG_fail;
19626 swig_obj[0] = args;
19627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19628 if (!SWIG_IsOK(res1)) {
19629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19630 }
19631 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19632 {
19633 PyThreadState* __tstate = wxPyBeginAllowThreads();
19634 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19635 wxPyEndAllowThreads(__tstate);
19636 if (PyErr_Occurred()) SWIG_fail;
19637 }
19638 resultobj = SWIG_From_int(static_cast< int >(result));
19639 return resultobj;
19640 fail:
19641 return NULL;
19642 }
19643
19644
19645 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19646 PyObject *resultobj = 0;
19647 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19648 int result;
19649 void *argp1 = 0 ;
19650 int res1 = 0 ;
19651 PyObject *swig_obj[1] ;
19652
19653 if (!args) SWIG_fail;
19654 swig_obj[0] = args;
19655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19656 if (!SWIG_IsOK(res1)) {
19657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19658 }
19659 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19660 {
19661 PyThreadState* __tstate = wxPyBeginAllowThreads();
19662 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19663 wxPyEndAllowThreads(__tstate);
19664 if (PyErr_Occurred()) SWIG_fail;
19665 }
19666 resultobj = SWIG_From_int(static_cast< int >(result));
19667 return resultobj;
19668 fail:
19669 return NULL;
19670 }
19671
19672
19673 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19674 PyObject *resultobj = 0;
19675 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19676 int arg2 ;
19677 void *argp1 = 0 ;
19678 int res1 = 0 ;
19679 int val2 ;
19680 int ecode2 = 0 ;
19681 PyObject * obj0 = 0 ;
19682 PyObject * obj1 = 0 ;
19683 char * kwnames[] = {
19684 (char *) "self",(char *) "orient", NULL
19685 };
19686
19687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19689 if (!SWIG_IsOK(res1)) {
19690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19691 }
19692 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19693 ecode2 = SWIG_AsVal_int(obj1, &val2);
19694 if (!SWIG_IsOK(ecode2)) {
19695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19696 }
19697 arg2 = static_cast< int >(val2);
19698 {
19699 PyThreadState* __tstate = wxPyBeginAllowThreads();
19700 (arg1)->SetOrientation(arg2);
19701 wxPyEndAllowThreads(__tstate);
19702 if (PyErr_Occurred()) SWIG_fail;
19703 }
19704 resultobj = SWIG_Py_Void();
19705 return resultobj;
19706 fail:
19707 return NULL;
19708 }
19709
19710
19711 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19712 PyObject *resultobj = 0;
19713 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19714 int arg2 ;
19715 void *argp1 = 0 ;
19716 int res1 = 0 ;
19717 int val2 ;
19718 int ecode2 = 0 ;
19719 PyObject * obj0 = 0 ;
19720 PyObject * obj1 = 0 ;
19721 char * kwnames[] = {
19722 (char *) "self",(char *) "pos", NULL
19723 };
19724
19725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19727 if (!SWIG_IsOK(res1)) {
19728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19729 }
19730 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19731 ecode2 = SWIG_AsVal_int(obj1, &val2);
19732 if (!SWIG_IsOK(ecode2)) {
19733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19734 }
19735 arg2 = static_cast< int >(val2);
19736 {
19737 PyThreadState* __tstate = wxPyBeginAllowThreads();
19738 (arg1)->SetPosition(arg2);
19739 wxPyEndAllowThreads(__tstate);
19740 if (PyErr_Occurred()) SWIG_fail;
19741 }
19742 resultobj = SWIG_Py_Void();
19743 return resultobj;
19744 fail:
19745 return NULL;
19746 }
19747
19748
19749 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19750 PyObject *obj;
19751 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19752 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19753 return SWIG_Py_Void();
19754 }
19755
19756 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19757 return SWIG_Python_InitShadowInstance(args);
19758 }
19759
19760 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19761 PyObject *resultobj = 0;
19762 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19763 wxMouseEvent *result = 0 ;
19764 int val1 ;
19765 int ecode1 = 0 ;
19766 PyObject * obj0 = 0 ;
19767 char * kwnames[] = {
19768 (char *) "mouseType", NULL
19769 };
19770
19771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19772 if (obj0) {
19773 ecode1 = SWIG_AsVal_int(obj0, &val1);
19774 if (!SWIG_IsOK(ecode1)) {
19775 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19776 }
19777 arg1 = static_cast< wxEventType >(val1);
19778 }
19779 {
19780 PyThreadState* __tstate = wxPyBeginAllowThreads();
19781 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19782 wxPyEndAllowThreads(__tstate);
19783 if (PyErr_Occurred()) SWIG_fail;
19784 }
19785 {
19786 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19787 }
19788 return resultobj;
19789 fail:
19790 return NULL;
19791 }
19792
19793
19794 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19795 PyObject *resultobj = 0;
19796 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19797 bool result;
19798 void *argp1 = 0 ;
19799 int res1 = 0 ;
19800 PyObject *swig_obj[1] ;
19801
19802 if (!args) SWIG_fail;
19803 swig_obj[0] = args;
19804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19805 if (!SWIG_IsOK(res1)) {
19806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19807 }
19808 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19812 wxPyEndAllowThreads(__tstate);
19813 if (PyErr_Occurred()) SWIG_fail;
19814 }
19815 {
19816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19817 }
19818 return resultobj;
19819 fail:
19820 return NULL;
19821 }
19822
19823
19824 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19825 PyObject *resultobj = 0;
19826 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19827 int arg2 = (int) wxMOUSE_BTN_ANY ;
19828 bool result;
19829 void *argp1 = 0 ;
19830 int res1 = 0 ;
19831 int val2 ;
19832 int ecode2 = 0 ;
19833 PyObject * obj0 = 0 ;
19834 PyObject * obj1 = 0 ;
19835 char * kwnames[] = {
19836 (char *) "self",(char *) "but", NULL
19837 };
19838
19839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19841 if (!SWIG_IsOK(res1)) {
19842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19843 }
19844 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19845 if (obj1) {
19846 ecode2 = SWIG_AsVal_int(obj1, &val2);
19847 if (!SWIG_IsOK(ecode2)) {
19848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19849 }
19850 arg2 = static_cast< int >(val2);
19851 }
19852 {
19853 PyThreadState* __tstate = wxPyBeginAllowThreads();
19854 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19855 wxPyEndAllowThreads(__tstate);
19856 if (PyErr_Occurred()) SWIG_fail;
19857 }
19858 {
19859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19860 }
19861 return resultobj;
19862 fail:
19863 return NULL;
19864 }
19865
19866
19867 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19868 PyObject *resultobj = 0;
19869 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19870 int arg2 = (int) wxMOUSE_BTN_ANY ;
19871 bool result;
19872 void *argp1 = 0 ;
19873 int res1 = 0 ;
19874 int val2 ;
19875 int ecode2 = 0 ;
19876 PyObject * obj0 = 0 ;
19877 PyObject * obj1 = 0 ;
19878 char * kwnames[] = {
19879 (char *) "self",(char *) "but", NULL
19880 };
19881
19882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19884 if (!SWIG_IsOK(res1)) {
19885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19886 }
19887 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19888 if (obj1) {
19889 ecode2 = SWIG_AsVal_int(obj1, &val2);
19890 if (!SWIG_IsOK(ecode2)) {
19891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19892 }
19893 arg2 = static_cast< int >(val2);
19894 }
19895 {
19896 PyThreadState* __tstate = wxPyBeginAllowThreads();
19897 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19898 wxPyEndAllowThreads(__tstate);
19899 if (PyErr_Occurred()) SWIG_fail;
19900 }
19901 {
19902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19903 }
19904 return resultobj;
19905 fail:
19906 return NULL;
19907 }
19908
19909
19910 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19911 PyObject *resultobj = 0;
19912 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19913 int arg2 = (int) wxMOUSE_BTN_ANY ;
19914 bool result;
19915 void *argp1 = 0 ;
19916 int res1 = 0 ;
19917 int val2 ;
19918 int ecode2 = 0 ;
19919 PyObject * obj0 = 0 ;
19920 PyObject * obj1 = 0 ;
19921 char * kwnames[] = {
19922 (char *) "self",(char *) "but", NULL
19923 };
19924
19925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19927 if (!SWIG_IsOK(res1)) {
19928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19929 }
19930 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19931 if (obj1) {
19932 ecode2 = SWIG_AsVal_int(obj1, &val2);
19933 if (!SWIG_IsOK(ecode2)) {
19934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19935 }
19936 arg2 = static_cast< int >(val2);
19937 }
19938 {
19939 PyThreadState* __tstate = wxPyBeginAllowThreads();
19940 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19941 wxPyEndAllowThreads(__tstate);
19942 if (PyErr_Occurred()) SWIG_fail;
19943 }
19944 {
19945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19946 }
19947 return resultobj;
19948 fail:
19949 return NULL;
19950 }
19951
19952
19953 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19954 PyObject *resultobj = 0;
19955 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19956 int arg2 ;
19957 bool result;
19958 void *argp1 = 0 ;
19959 int res1 = 0 ;
19960 int val2 ;
19961 int ecode2 = 0 ;
19962 PyObject * obj0 = 0 ;
19963 PyObject * obj1 = 0 ;
19964 char * kwnames[] = {
19965 (char *) "self",(char *) "button", NULL
19966 };
19967
19968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19970 if (!SWIG_IsOK(res1)) {
19971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19972 }
19973 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19974 ecode2 = SWIG_AsVal_int(obj1, &val2);
19975 if (!SWIG_IsOK(ecode2)) {
19976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19977 }
19978 arg2 = static_cast< int >(val2);
19979 {
19980 PyThreadState* __tstate = wxPyBeginAllowThreads();
19981 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19982 wxPyEndAllowThreads(__tstate);
19983 if (PyErr_Occurred()) SWIG_fail;
19984 }
19985 {
19986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19987 }
19988 return resultobj;
19989 fail:
19990 return NULL;
19991 }
19992
19993
19994 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19995 PyObject *resultobj = 0;
19996 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19997 int arg2 ;
19998 bool result;
19999 void *argp1 = 0 ;
20000 int res1 = 0 ;
20001 int val2 ;
20002 int ecode2 = 0 ;
20003 PyObject * obj0 = 0 ;
20004 PyObject * obj1 = 0 ;
20005 char * kwnames[] = {
20006 (char *) "self",(char *) "but", NULL
20007 };
20008
20009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20011 if (!SWIG_IsOK(res1)) {
20012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20013 }
20014 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20015 ecode2 = SWIG_AsVal_int(obj1, &val2);
20016 if (!SWIG_IsOK(ecode2)) {
20017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20018 }
20019 arg2 = static_cast< int >(val2);
20020 {
20021 PyThreadState* __tstate = wxPyBeginAllowThreads();
20022 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20023 wxPyEndAllowThreads(__tstate);
20024 if (PyErr_Occurred()) SWIG_fail;
20025 }
20026 {
20027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20028 }
20029 return resultobj;
20030 fail:
20031 return NULL;
20032 }
20033
20034
20035 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20036 PyObject *resultobj = 0;
20037 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20038 int result;
20039 void *argp1 = 0 ;
20040 int res1 = 0 ;
20041 PyObject *swig_obj[1] ;
20042
20043 if (!args) SWIG_fail;
20044 swig_obj[0] = args;
20045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20046 if (!SWIG_IsOK(res1)) {
20047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20048 }
20049 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20050 {
20051 PyThreadState* __tstate = wxPyBeginAllowThreads();
20052 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20053 wxPyEndAllowThreads(__tstate);
20054 if (PyErr_Occurred()) SWIG_fail;
20055 }
20056 resultobj = SWIG_From_int(static_cast< int >(result));
20057 return resultobj;
20058 fail:
20059 return NULL;
20060 }
20061
20062
20063 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20064 PyObject *resultobj = 0;
20065 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20066 bool result;
20067 void *argp1 = 0 ;
20068 int res1 = 0 ;
20069 PyObject *swig_obj[1] ;
20070
20071 if (!args) SWIG_fail;
20072 swig_obj[0] = args;
20073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20074 if (!SWIG_IsOK(res1)) {
20075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20076 }
20077 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20078 {
20079 PyThreadState* __tstate = wxPyBeginAllowThreads();
20080 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20081 wxPyEndAllowThreads(__tstate);
20082 if (PyErr_Occurred()) SWIG_fail;
20083 }
20084 {
20085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20086 }
20087 return resultobj;
20088 fail:
20089 return NULL;
20090 }
20091
20092
20093 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20094 PyObject *resultobj = 0;
20095 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20096 bool result;
20097 void *argp1 = 0 ;
20098 int res1 = 0 ;
20099 PyObject *swig_obj[1] ;
20100
20101 if (!args) SWIG_fail;
20102 swig_obj[0] = args;
20103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20104 if (!SWIG_IsOK(res1)) {
20105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20106 }
20107 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20108 {
20109 PyThreadState* __tstate = wxPyBeginAllowThreads();
20110 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20111 wxPyEndAllowThreads(__tstate);
20112 if (PyErr_Occurred()) SWIG_fail;
20113 }
20114 {
20115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20116 }
20117 return resultobj;
20118 fail:
20119 return NULL;
20120 }
20121
20122
20123 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20124 PyObject *resultobj = 0;
20125 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20126 bool result;
20127 void *argp1 = 0 ;
20128 int res1 = 0 ;
20129 PyObject *swig_obj[1] ;
20130
20131 if (!args) SWIG_fail;
20132 swig_obj[0] = args;
20133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20134 if (!SWIG_IsOK(res1)) {
20135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20136 }
20137 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20138 {
20139 PyThreadState* __tstate = wxPyBeginAllowThreads();
20140 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20141 wxPyEndAllowThreads(__tstate);
20142 if (PyErr_Occurred()) SWIG_fail;
20143 }
20144 {
20145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20146 }
20147 return resultobj;
20148 fail:
20149 return NULL;
20150 }
20151
20152
20153 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20154 PyObject *resultobj = 0;
20155 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20156 bool result;
20157 void *argp1 = 0 ;
20158 int res1 = 0 ;
20159 PyObject *swig_obj[1] ;
20160
20161 if (!args) SWIG_fail;
20162 swig_obj[0] = args;
20163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20164 if (!SWIG_IsOK(res1)) {
20165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20166 }
20167 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20168 {
20169 PyThreadState* __tstate = wxPyBeginAllowThreads();
20170 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20171 wxPyEndAllowThreads(__tstate);
20172 if (PyErr_Occurred()) SWIG_fail;
20173 }
20174 {
20175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20176 }
20177 return resultobj;
20178 fail:
20179 return NULL;
20180 }
20181
20182
20183 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20184 PyObject *resultobj = 0;
20185 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20186 bool result;
20187 void *argp1 = 0 ;
20188 int res1 = 0 ;
20189 PyObject *swig_obj[1] ;
20190
20191 if (!args) SWIG_fail;
20192 swig_obj[0] = args;
20193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20194 if (!SWIG_IsOK(res1)) {
20195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20196 }
20197 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20198 {
20199 PyThreadState* __tstate = wxPyBeginAllowThreads();
20200 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20201 wxPyEndAllowThreads(__tstate);
20202 if (PyErr_Occurred()) SWIG_fail;
20203 }
20204 {
20205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20206 }
20207 return resultobj;
20208 fail:
20209 return NULL;
20210 }
20211
20212
20213 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20214 PyObject *resultobj = 0;
20215 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20216 bool result;
20217 void *argp1 = 0 ;
20218 int res1 = 0 ;
20219 PyObject *swig_obj[1] ;
20220
20221 if (!args) SWIG_fail;
20222 swig_obj[0] = args;
20223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20224 if (!SWIG_IsOK(res1)) {
20225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20226 }
20227 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20228 {
20229 PyThreadState* __tstate = wxPyBeginAllowThreads();
20230 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20231 wxPyEndAllowThreads(__tstate);
20232 if (PyErr_Occurred()) SWIG_fail;
20233 }
20234 {
20235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20236 }
20237 return resultobj;
20238 fail:
20239 return NULL;
20240 }
20241
20242
20243 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20244 PyObject *resultobj = 0;
20245 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20246 bool result;
20247 void *argp1 = 0 ;
20248 int res1 = 0 ;
20249 PyObject *swig_obj[1] ;
20250
20251 if (!args) SWIG_fail;
20252 swig_obj[0] = args;
20253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20254 if (!SWIG_IsOK(res1)) {
20255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20256 }
20257 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20258 {
20259 PyThreadState* __tstate = wxPyBeginAllowThreads();
20260 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20261 wxPyEndAllowThreads(__tstate);
20262 if (PyErr_Occurred()) SWIG_fail;
20263 }
20264 {
20265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20266 }
20267 return resultobj;
20268 fail:
20269 return NULL;
20270 }
20271
20272
20273 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20274 PyObject *resultobj = 0;
20275 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20276 bool result;
20277 void *argp1 = 0 ;
20278 int res1 = 0 ;
20279 PyObject *swig_obj[1] ;
20280
20281 if (!args) SWIG_fail;
20282 swig_obj[0] = args;
20283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20284 if (!SWIG_IsOK(res1)) {
20285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20286 }
20287 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20288 {
20289 PyThreadState* __tstate = wxPyBeginAllowThreads();
20290 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20291 wxPyEndAllowThreads(__tstate);
20292 if (PyErr_Occurred()) SWIG_fail;
20293 }
20294 {
20295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20296 }
20297 return resultobj;
20298 fail:
20299 return NULL;
20300 }
20301
20302
20303 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20304 PyObject *resultobj = 0;
20305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20306 bool result;
20307 void *argp1 = 0 ;
20308 int res1 = 0 ;
20309 PyObject *swig_obj[1] ;
20310
20311 if (!args) SWIG_fail;
20312 swig_obj[0] = args;
20313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20314 if (!SWIG_IsOK(res1)) {
20315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20316 }
20317 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20318 {
20319 PyThreadState* __tstate = wxPyBeginAllowThreads();
20320 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20321 wxPyEndAllowThreads(__tstate);
20322 if (PyErr_Occurred()) SWIG_fail;
20323 }
20324 {
20325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20326 }
20327 return resultobj;
20328 fail:
20329 return NULL;
20330 }
20331
20332
20333 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20334 PyObject *resultobj = 0;
20335 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20336 bool result;
20337 void *argp1 = 0 ;
20338 int res1 = 0 ;
20339 PyObject *swig_obj[1] ;
20340
20341 if (!args) SWIG_fail;
20342 swig_obj[0] = args;
20343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20344 if (!SWIG_IsOK(res1)) {
20345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20346 }
20347 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20348 {
20349 PyThreadState* __tstate = wxPyBeginAllowThreads();
20350 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20351 wxPyEndAllowThreads(__tstate);
20352 if (PyErr_Occurred()) SWIG_fail;
20353 }
20354 {
20355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20356 }
20357 return resultobj;
20358 fail:
20359 return NULL;
20360 }
20361
20362
20363 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20364 PyObject *resultobj = 0;
20365 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20366 bool result;
20367 void *argp1 = 0 ;
20368 int res1 = 0 ;
20369 PyObject *swig_obj[1] ;
20370
20371 if (!args) SWIG_fail;
20372 swig_obj[0] = args;
20373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20374 if (!SWIG_IsOK(res1)) {
20375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20376 }
20377 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20378 {
20379 PyThreadState* __tstate = wxPyBeginAllowThreads();
20380 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20381 wxPyEndAllowThreads(__tstate);
20382 if (PyErr_Occurred()) SWIG_fail;
20383 }
20384 {
20385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20386 }
20387 return resultobj;
20388 fail:
20389 return NULL;
20390 }
20391
20392
20393 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20394 PyObject *resultobj = 0;
20395 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20396 bool result;
20397 void *argp1 = 0 ;
20398 int res1 = 0 ;
20399 PyObject *swig_obj[1] ;
20400
20401 if (!args) SWIG_fail;
20402 swig_obj[0] = args;
20403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20404 if (!SWIG_IsOK(res1)) {
20405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20406 }
20407 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20408 {
20409 PyThreadState* __tstate = wxPyBeginAllowThreads();
20410 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 {
20415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20416 }
20417 return resultobj;
20418 fail:
20419 return NULL;
20420 }
20421
20422
20423 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20424 PyObject *resultobj = 0;
20425 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20426 bool result;
20427 void *argp1 = 0 ;
20428 int res1 = 0 ;
20429 PyObject *swig_obj[1] ;
20430
20431 if (!args) SWIG_fail;
20432 swig_obj[0] = args;
20433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20434 if (!SWIG_IsOK(res1)) {
20435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20436 }
20437 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20438 {
20439 PyThreadState* __tstate = wxPyBeginAllowThreads();
20440 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20441 wxPyEndAllowThreads(__tstate);
20442 if (PyErr_Occurred()) SWIG_fail;
20443 }
20444 {
20445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20446 }
20447 return resultobj;
20448 fail:
20449 return NULL;
20450 }
20451
20452
20453 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20454 PyObject *resultobj = 0;
20455 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20456 bool result;
20457 void *argp1 = 0 ;
20458 int res1 = 0 ;
20459 PyObject *swig_obj[1] ;
20460
20461 if (!args) SWIG_fail;
20462 swig_obj[0] = args;
20463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20464 if (!SWIG_IsOK(res1)) {
20465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20466 }
20467 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20468 {
20469 PyThreadState* __tstate = wxPyBeginAllowThreads();
20470 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20471 wxPyEndAllowThreads(__tstate);
20472 if (PyErr_Occurred()) SWIG_fail;
20473 }
20474 {
20475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20476 }
20477 return resultobj;
20478 fail:
20479 return NULL;
20480 }
20481
20482
20483 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20484 PyObject *resultobj = 0;
20485 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20486 bool result;
20487 void *argp1 = 0 ;
20488 int res1 = 0 ;
20489 PyObject *swig_obj[1] ;
20490
20491 if (!args) SWIG_fail;
20492 swig_obj[0] = args;
20493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20494 if (!SWIG_IsOK(res1)) {
20495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20496 }
20497 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20498 {
20499 PyThreadState* __tstate = wxPyBeginAllowThreads();
20500 result = (bool)(arg1)->LeftIsDown();
20501 wxPyEndAllowThreads(__tstate);
20502 if (PyErr_Occurred()) SWIG_fail;
20503 }
20504 {
20505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20506 }
20507 return resultobj;
20508 fail:
20509 return NULL;
20510 }
20511
20512
20513 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20514 PyObject *resultobj = 0;
20515 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20516 bool result;
20517 void *argp1 = 0 ;
20518 int res1 = 0 ;
20519 PyObject *swig_obj[1] ;
20520
20521 if (!args) SWIG_fail;
20522 swig_obj[0] = args;
20523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20524 if (!SWIG_IsOK(res1)) {
20525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20526 }
20527 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20528 {
20529 PyThreadState* __tstate = wxPyBeginAllowThreads();
20530 result = (bool)(arg1)->MiddleIsDown();
20531 wxPyEndAllowThreads(__tstate);
20532 if (PyErr_Occurred()) SWIG_fail;
20533 }
20534 {
20535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20536 }
20537 return resultobj;
20538 fail:
20539 return NULL;
20540 }
20541
20542
20543 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20544 PyObject *resultobj = 0;
20545 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20546 bool result;
20547 void *argp1 = 0 ;
20548 int res1 = 0 ;
20549 PyObject *swig_obj[1] ;
20550
20551 if (!args) SWIG_fail;
20552 swig_obj[0] = args;
20553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20554 if (!SWIG_IsOK(res1)) {
20555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20556 }
20557 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20558 {
20559 PyThreadState* __tstate = wxPyBeginAllowThreads();
20560 result = (bool)(arg1)->RightIsDown();
20561 wxPyEndAllowThreads(__tstate);
20562 if (PyErr_Occurred()) SWIG_fail;
20563 }
20564 {
20565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20566 }
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20574 PyObject *resultobj = 0;
20575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20576 bool result;
20577 void *argp1 = 0 ;
20578 int res1 = 0 ;
20579 PyObject *swig_obj[1] ;
20580
20581 if (!args) SWIG_fail;
20582 swig_obj[0] = args;
20583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20584 if (!SWIG_IsOK(res1)) {
20585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20586 }
20587 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20588 {
20589 PyThreadState* __tstate = wxPyBeginAllowThreads();
20590 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20591 wxPyEndAllowThreads(__tstate);
20592 if (PyErr_Occurred()) SWIG_fail;
20593 }
20594 {
20595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20596 }
20597 return resultobj;
20598 fail:
20599 return NULL;
20600 }
20601
20602
20603 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20604 PyObject *resultobj = 0;
20605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20606 bool result;
20607 void *argp1 = 0 ;
20608 int res1 = 0 ;
20609 PyObject *swig_obj[1] ;
20610
20611 if (!args) SWIG_fail;
20612 swig_obj[0] = args;
20613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20614 if (!SWIG_IsOK(res1)) {
20615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20616 }
20617 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20618 {
20619 PyThreadState* __tstate = wxPyBeginAllowThreads();
20620 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20621 wxPyEndAllowThreads(__tstate);
20622 if (PyErr_Occurred()) SWIG_fail;
20623 }
20624 {
20625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20626 }
20627 return resultobj;
20628 fail:
20629 return NULL;
20630 }
20631
20632
20633 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20634 PyObject *resultobj = 0;
20635 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20636 bool result;
20637 void *argp1 = 0 ;
20638 int res1 = 0 ;
20639 PyObject *swig_obj[1] ;
20640
20641 if (!args) SWIG_fail;
20642 swig_obj[0] = args;
20643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20644 if (!SWIG_IsOK(res1)) {
20645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20646 }
20647 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20648 {
20649 PyThreadState* __tstate = wxPyBeginAllowThreads();
20650 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20651 wxPyEndAllowThreads(__tstate);
20652 if (PyErr_Occurred()) SWIG_fail;
20653 }
20654 {
20655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20656 }
20657 return resultobj;
20658 fail:
20659 return NULL;
20660 }
20661
20662
20663 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20664 PyObject *resultobj = 0;
20665 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20666 bool result;
20667 void *argp1 = 0 ;
20668 int res1 = 0 ;
20669 PyObject *swig_obj[1] ;
20670
20671 if (!args) SWIG_fail;
20672 swig_obj[0] = args;
20673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20674 if (!SWIG_IsOK(res1)) {
20675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20676 }
20677 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20678 {
20679 PyThreadState* __tstate = wxPyBeginAllowThreads();
20680 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20681 wxPyEndAllowThreads(__tstate);
20682 if (PyErr_Occurred()) SWIG_fail;
20683 }
20684 {
20685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20686 }
20687 return resultobj;
20688 fail:
20689 return NULL;
20690 }
20691
20692
20693 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20694 PyObject *resultobj = 0;
20695 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20696 wxPoint result;
20697 void *argp1 = 0 ;
20698 int res1 = 0 ;
20699 PyObject *swig_obj[1] ;
20700
20701 if (!args) SWIG_fail;
20702 swig_obj[0] = args;
20703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20704 if (!SWIG_IsOK(res1)) {
20705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20706 }
20707 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20708 {
20709 PyThreadState* __tstate = wxPyBeginAllowThreads();
20710 result = (arg1)->GetPosition();
20711 wxPyEndAllowThreads(__tstate);
20712 if (PyErr_Occurred()) SWIG_fail;
20713 }
20714 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20715 return resultobj;
20716 fail:
20717 return NULL;
20718 }
20719
20720
20721 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20722 PyObject *resultobj = 0;
20723 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20724 long *arg2 = (long *) 0 ;
20725 long *arg3 = (long *) 0 ;
20726 void *argp1 = 0 ;
20727 int res1 = 0 ;
20728 long temp2 ;
20729 int res2 = SWIG_TMPOBJ ;
20730 long temp3 ;
20731 int res3 = SWIG_TMPOBJ ;
20732 PyObject *swig_obj[1] ;
20733
20734 arg2 = &temp2;
20735 arg3 = &temp3;
20736 if (!args) SWIG_fail;
20737 swig_obj[0] = args;
20738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20739 if (!SWIG_IsOK(res1)) {
20740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20741 }
20742 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20743 {
20744 PyThreadState* __tstate = wxPyBeginAllowThreads();
20745 (arg1)->GetPosition(arg2,arg3);
20746 wxPyEndAllowThreads(__tstate);
20747 if (PyErr_Occurred()) SWIG_fail;
20748 }
20749 resultobj = SWIG_Py_Void();
20750 if (SWIG_IsTmpObj(res2)) {
20751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20752 } else {
20753 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20755 }
20756 if (SWIG_IsTmpObj(res3)) {
20757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20758 } else {
20759 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20761 }
20762 return resultobj;
20763 fail:
20764 return NULL;
20765 }
20766
20767
20768 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20769 PyObject *resultobj = 0;
20770 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20771 wxDC *arg2 = 0 ;
20772 wxPoint result;
20773 void *argp1 = 0 ;
20774 int res1 = 0 ;
20775 void *argp2 = 0 ;
20776 int res2 = 0 ;
20777 PyObject * obj0 = 0 ;
20778 PyObject * obj1 = 0 ;
20779 char * kwnames[] = {
20780 (char *) "self",(char *) "dc", NULL
20781 };
20782
20783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20785 if (!SWIG_IsOK(res1)) {
20786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20787 }
20788 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20789 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20790 if (!SWIG_IsOK(res2)) {
20791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20792 }
20793 if (!argp2) {
20794 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20795 }
20796 arg2 = reinterpret_cast< wxDC * >(argp2);
20797 {
20798 PyThreadState* __tstate = wxPyBeginAllowThreads();
20799 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20800 wxPyEndAllowThreads(__tstate);
20801 if (PyErr_Occurred()) SWIG_fail;
20802 }
20803 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20804 return resultobj;
20805 fail:
20806 return NULL;
20807 }
20808
20809
20810 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20811 PyObject *resultobj = 0;
20812 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20813 int result;
20814 void *argp1 = 0 ;
20815 int res1 = 0 ;
20816 PyObject *swig_obj[1] ;
20817
20818 if (!args) SWIG_fail;
20819 swig_obj[0] = args;
20820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20821 if (!SWIG_IsOK(res1)) {
20822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20823 }
20824 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20825 {
20826 PyThreadState* __tstate = wxPyBeginAllowThreads();
20827 result = (int)((wxMouseEvent const *)arg1)->GetX();
20828 wxPyEndAllowThreads(__tstate);
20829 if (PyErr_Occurred()) SWIG_fail;
20830 }
20831 resultobj = SWIG_From_int(static_cast< int >(result));
20832 return resultobj;
20833 fail:
20834 return NULL;
20835 }
20836
20837
20838 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20839 PyObject *resultobj = 0;
20840 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20841 int result;
20842 void *argp1 = 0 ;
20843 int res1 = 0 ;
20844 PyObject *swig_obj[1] ;
20845
20846 if (!args) SWIG_fail;
20847 swig_obj[0] = args;
20848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20849 if (!SWIG_IsOK(res1)) {
20850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20851 }
20852 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20853 {
20854 PyThreadState* __tstate = wxPyBeginAllowThreads();
20855 result = (int)((wxMouseEvent const *)arg1)->GetY();
20856 wxPyEndAllowThreads(__tstate);
20857 if (PyErr_Occurred()) SWIG_fail;
20858 }
20859 resultobj = SWIG_From_int(static_cast< int >(result));
20860 return resultobj;
20861 fail:
20862 return NULL;
20863 }
20864
20865
20866 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20867 PyObject *resultobj = 0;
20868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20869 int result;
20870 void *argp1 = 0 ;
20871 int res1 = 0 ;
20872 PyObject *swig_obj[1] ;
20873
20874 if (!args) SWIG_fail;
20875 swig_obj[0] = args;
20876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20877 if (!SWIG_IsOK(res1)) {
20878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20879 }
20880 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20881 {
20882 PyThreadState* __tstate = wxPyBeginAllowThreads();
20883 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20884 wxPyEndAllowThreads(__tstate);
20885 if (PyErr_Occurred()) SWIG_fail;
20886 }
20887 resultobj = SWIG_From_int(static_cast< int >(result));
20888 return resultobj;
20889 fail:
20890 return NULL;
20891 }
20892
20893
20894 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20895 PyObject *resultobj = 0;
20896 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20897 int result;
20898 void *argp1 = 0 ;
20899 int res1 = 0 ;
20900 PyObject *swig_obj[1] ;
20901
20902 if (!args) SWIG_fail;
20903 swig_obj[0] = args;
20904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20905 if (!SWIG_IsOK(res1)) {
20906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20907 }
20908 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20909 {
20910 PyThreadState* __tstate = wxPyBeginAllowThreads();
20911 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20912 wxPyEndAllowThreads(__tstate);
20913 if (PyErr_Occurred()) SWIG_fail;
20914 }
20915 resultobj = SWIG_From_int(static_cast< int >(result));
20916 return resultobj;
20917 fail:
20918 return NULL;
20919 }
20920
20921
20922 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20923 PyObject *resultobj = 0;
20924 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20925 int result;
20926 void *argp1 = 0 ;
20927 int res1 = 0 ;
20928 PyObject *swig_obj[1] ;
20929
20930 if (!args) SWIG_fail;
20931 swig_obj[0] = args;
20932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20933 if (!SWIG_IsOK(res1)) {
20934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20935 }
20936 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20937 {
20938 PyThreadState* __tstate = wxPyBeginAllowThreads();
20939 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20940 wxPyEndAllowThreads(__tstate);
20941 if (PyErr_Occurred()) SWIG_fail;
20942 }
20943 resultobj = SWIG_From_int(static_cast< int >(result));
20944 return resultobj;
20945 fail:
20946 return NULL;
20947 }
20948
20949
20950 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20951 PyObject *resultobj = 0;
20952 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20953 bool result;
20954 void *argp1 = 0 ;
20955 int res1 = 0 ;
20956 PyObject *swig_obj[1] ;
20957
20958 if (!args) SWIG_fail;
20959 swig_obj[0] = args;
20960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20961 if (!SWIG_IsOK(res1)) {
20962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20963 }
20964 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20965 {
20966 PyThreadState* __tstate = wxPyBeginAllowThreads();
20967 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20968 wxPyEndAllowThreads(__tstate);
20969 if (PyErr_Occurred()) SWIG_fail;
20970 }
20971 {
20972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20973 }
20974 return resultobj;
20975 fail:
20976 return NULL;
20977 }
20978
20979
20980 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20981 PyObject *resultobj = 0;
20982 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20983 int arg2 ;
20984 void *argp1 = 0 ;
20985 int res1 = 0 ;
20986 int val2 ;
20987 int ecode2 = 0 ;
20988 PyObject *swig_obj[2] ;
20989
20990 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20992 if (!SWIG_IsOK(res1)) {
20993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20994 }
20995 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20996 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20997 if (!SWIG_IsOK(ecode2)) {
20998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20999 }
21000 arg2 = static_cast< int >(val2);
21001 if (arg1) (arg1)->m_x = arg2;
21002
21003 resultobj = SWIG_Py_Void();
21004 return resultobj;
21005 fail:
21006 return NULL;
21007 }
21008
21009
21010 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21011 PyObject *resultobj = 0;
21012 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21013 int result;
21014 void *argp1 = 0 ;
21015 int res1 = 0 ;
21016 PyObject *swig_obj[1] ;
21017
21018 if (!args) SWIG_fail;
21019 swig_obj[0] = args;
21020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21021 if (!SWIG_IsOK(res1)) {
21022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21023 }
21024 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21025 result = (int) ((arg1)->m_x);
21026 resultobj = SWIG_From_int(static_cast< int >(result));
21027 return resultobj;
21028 fail:
21029 return NULL;
21030 }
21031
21032
21033 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21034 PyObject *resultobj = 0;
21035 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21036 int arg2 ;
21037 void *argp1 = 0 ;
21038 int res1 = 0 ;
21039 int val2 ;
21040 int ecode2 = 0 ;
21041 PyObject *swig_obj[2] ;
21042
21043 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21045 if (!SWIG_IsOK(res1)) {
21046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21047 }
21048 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21049 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21050 if (!SWIG_IsOK(ecode2)) {
21051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21052 }
21053 arg2 = static_cast< int >(val2);
21054 if (arg1) (arg1)->m_y = arg2;
21055
21056 resultobj = SWIG_Py_Void();
21057 return resultobj;
21058 fail:
21059 return NULL;
21060 }
21061
21062
21063 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21064 PyObject *resultobj = 0;
21065 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21066 int result;
21067 void *argp1 = 0 ;
21068 int res1 = 0 ;
21069 PyObject *swig_obj[1] ;
21070
21071 if (!args) SWIG_fail;
21072 swig_obj[0] = args;
21073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21074 if (!SWIG_IsOK(res1)) {
21075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21076 }
21077 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21078 result = (int) ((arg1)->m_y);
21079 resultobj = SWIG_From_int(static_cast< int >(result));
21080 return resultobj;
21081 fail:
21082 return NULL;
21083 }
21084
21085
21086 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21087 PyObject *resultobj = 0;
21088 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21089 bool arg2 ;
21090 void *argp1 = 0 ;
21091 int res1 = 0 ;
21092 bool val2 ;
21093 int ecode2 = 0 ;
21094 PyObject *swig_obj[2] ;
21095
21096 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21098 if (!SWIG_IsOK(res1)) {
21099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21100 }
21101 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21102 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21103 if (!SWIG_IsOK(ecode2)) {
21104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21105 }
21106 arg2 = static_cast< bool >(val2);
21107 if (arg1) (arg1)->m_leftDown = arg2;
21108
21109 resultobj = SWIG_Py_Void();
21110 return resultobj;
21111 fail:
21112 return NULL;
21113 }
21114
21115
21116 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21117 PyObject *resultobj = 0;
21118 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21119 bool result;
21120 void *argp1 = 0 ;
21121 int res1 = 0 ;
21122 PyObject *swig_obj[1] ;
21123
21124 if (!args) SWIG_fail;
21125 swig_obj[0] = args;
21126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21127 if (!SWIG_IsOK(res1)) {
21128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21129 }
21130 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21131 result = (bool) ((arg1)->m_leftDown);
21132 {
21133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21134 }
21135 return resultobj;
21136 fail:
21137 return NULL;
21138 }
21139
21140
21141 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21142 PyObject *resultobj = 0;
21143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21144 bool arg2 ;
21145 void *argp1 = 0 ;
21146 int res1 = 0 ;
21147 bool val2 ;
21148 int ecode2 = 0 ;
21149 PyObject *swig_obj[2] ;
21150
21151 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21153 if (!SWIG_IsOK(res1)) {
21154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21155 }
21156 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21157 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21158 if (!SWIG_IsOK(ecode2)) {
21159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21160 }
21161 arg2 = static_cast< bool >(val2);
21162 if (arg1) (arg1)->m_middleDown = arg2;
21163
21164 resultobj = SWIG_Py_Void();
21165 return resultobj;
21166 fail:
21167 return NULL;
21168 }
21169
21170
21171 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21172 PyObject *resultobj = 0;
21173 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21174 bool result;
21175 void *argp1 = 0 ;
21176 int res1 = 0 ;
21177 PyObject *swig_obj[1] ;
21178
21179 if (!args) SWIG_fail;
21180 swig_obj[0] = args;
21181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21182 if (!SWIG_IsOK(res1)) {
21183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21184 }
21185 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21186 result = (bool) ((arg1)->m_middleDown);
21187 {
21188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21189 }
21190 return resultobj;
21191 fail:
21192 return NULL;
21193 }
21194
21195
21196 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21197 PyObject *resultobj = 0;
21198 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21199 bool arg2 ;
21200 void *argp1 = 0 ;
21201 int res1 = 0 ;
21202 bool val2 ;
21203 int ecode2 = 0 ;
21204 PyObject *swig_obj[2] ;
21205
21206 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21208 if (!SWIG_IsOK(res1)) {
21209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21210 }
21211 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21212 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21213 if (!SWIG_IsOK(ecode2)) {
21214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21215 }
21216 arg2 = static_cast< bool >(val2);
21217 if (arg1) (arg1)->m_rightDown = arg2;
21218
21219 resultobj = SWIG_Py_Void();
21220 return resultobj;
21221 fail:
21222 return NULL;
21223 }
21224
21225
21226 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21227 PyObject *resultobj = 0;
21228 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21229 bool result;
21230 void *argp1 = 0 ;
21231 int res1 = 0 ;
21232 PyObject *swig_obj[1] ;
21233
21234 if (!args) SWIG_fail;
21235 swig_obj[0] = args;
21236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21237 if (!SWIG_IsOK(res1)) {
21238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21239 }
21240 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21241 result = (bool) ((arg1)->m_rightDown);
21242 {
21243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21244 }
21245 return resultobj;
21246 fail:
21247 return NULL;
21248 }
21249
21250
21251 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21252 PyObject *resultobj = 0;
21253 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21254 bool arg2 ;
21255 void *argp1 = 0 ;
21256 int res1 = 0 ;
21257 bool val2 ;
21258 int ecode2 = 0 ;
21259 PyObject *swig_obj[2] ;
21260
21261 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21263 if (!SWIG_IsOK(res1)) {
21264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21265 }
21266 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21267 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21268 if (!SWIG_IsOK(ecode2)) {
21269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21270 }
21271 arg2 = static_cast< bool >(val2);
21272 if (arg1) (arg1)->m_controlDown = arg2;
21273
21274 resultobj = SWIG_Py_Void();
21275 return resultobj;
21276 fail:
21277 return NULL;
21278 }
21279
21280
21281 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21282 PyObject *resultobj = 0;
21283 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21284 bool result;
21285 void *argp1 = 0 ;
21286 int res1 = 0 ;
21287 PyObject *swig_obj[1] ;
21288
21289 if (!args) SWIG_fail;
21290 swig_obj[0] = args;
21291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21292 if (!SWIG_IsOK(res1)) {
21293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21294 }
21295 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21296 result = (bool) ((arg1)->m_controlDown);
21297 {
21298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21299 }
21300 return resultobj;
21301 fail:
21302 return NULL;
21303 }
21304
21305
21306 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21307 PyObject *resultobj = 0;
21308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21309 bool arg2 ;
21310 void *argp1 = 0 ;
21311 int res1 = 0 ;
21312 bool val2 ;
21313 int ecode2 = 0 ;
21314 PyObject *swig_obj[2] ;
21315
21316 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21318 if (!SWIG_IsOK(res1)) {
21319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21320 }
21321 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21322 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21323 if (!SWIG_IsOK(ecode2)) {
21324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21325 }
21326 arg2 = static_cast< bool >(val2);
21327 if (arg1) (arg1)->m_shiftDown = arg2;
21328
21329 resultobj = SWIG_Py_Void();
21330 return resultobj;
21331 fail:
21332 return NULL;
21333 }
21334
21335
21336 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21337 PyObject *resultobj = 0;
21338 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21339 bool result;
21340 void *argp1 = 0 ;
21341 int res1 = 0 ;
21342 PyObject *swig_obj[1] ;
21343
21344 if (!args) SWIG_fail;
21345 swig_obj[0] = args;
21346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21347 if (!SWIG_IsOK(res1)) {
21348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21349 }
21350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21351 result = (bool) ((arg1)->m_shiftDown);
21352 {
21353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21354 }
21355 return resultobj;
21356 fail:
21357 return NULL;
21358 }
21359
21360
21361 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21362 PyObject *resultobj = 0;
21363 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21364 bool arg2 ;
21365 void *argp1 = 0 ;
21366 int res1 = 0 ;
21367 bool val2 ;
21368 int ecode2 = 0 ;
21369 PyObject *swig_obj[2] ;
21370
21371 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21373 if (!SWIG_IsOK(res1)) {
21374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21375 }
21376 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21377 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21378 if (!SWIG_IsOK(ecode2)) {
21379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21380 }
21381 arg2 = static_cast< bool >(val2);
21382 if (arg1) (arg1)->m_altDown = arg2;
21383
21384 resultobj = SWIG_Py_Void();
21385 return resultobj;
21386 fail:
21387 return NULL;
21388 }
21389
21390
21391 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21392 PyObject *resultobj = 0;
21393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21394 bool result;
21395 void *argp1 = 0 ;
21396 int res1 = 0 ;
21397 PyObject *swig_obj[1] ;
21398
21399 if (!args) SWIG_fail;
21400 swig_obj[0] = args;
21401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21402 if (!SWIG_IsOK(res1)) {
21403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21404 }
21405 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21406 result = (bool) ((arg1)->m_altDown);
21407 {
21408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21409 }
21410 return resultobj;
21411 fail:
21412 return NULL;
21413 }
21414
21415
21416 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21417 PyObject *resultobj = 0;
21418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21419 bool arg2 ;
21420 void *argp1 = 0 ;
21421 int res1 = 0 ;
21422 bool val2 ;
21423 int ecode2 = 0 ;
21424 PyObject *swig_obj[2] ;
21425
21426 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21428 if (!SWIG_IsOK(res1)) {
21429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21430 }
21431 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21432 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21433 if (!SWIG_IsOK(ecode2)) {
21434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21435 }
21436 arg2 = static_cast< bool >(val2);
21437 if (arg1) (arg1)->m_metaDown = arg2;
21438
21439 resultobj = SWIG_Py_Void();
21440 return resultobj;
21441 fail:
21442 return NULL;
21443 }
21444
21445
21446 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21447 PyObject *resultobj = 0;
21448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21449 bool result;
21450 void *argp1 = 0 ;
21451 int res1 = 0 ;
21452 PyObject *swig_obj[1] ;
21453
21454 if (!args) SWIG_fail;
21455 swig_obj[0] = args;
21456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21457 if (!SWIG_IsOK(res1)) {
21458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21459 }
21460 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21461 result = (bool) ((arg1)->m_metaDown);
21462 {
21463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21464 }
21465 return resultobj;
21466 fail:
21467 return NULL;
21468 }
21469
21470
21471 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21472 PyObject *resultobj = 0;
21473 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21474 int arg2 ;
21475 void *argp1 = 0 ;
21476 int res1 = 0 ;
21477 int val2 ;
21478 int ecode2 = 0 ;
21479 PyObject *swig_obj[2] ;
21480
21481 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21483 if (!SWIG_IsOK(res1)) {
21484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21485 }
21486 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21487 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21488 if (!SWIG_IsOK(ecode2)) {
21489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21490 }
21491 arg2 = static_cast< int >(val2);
21492 if (arg1) (arg1)->m_wheelRotation = arg2;
21493
21494 resultobj = SWIG_Py_Void();
21495 return resultobj;
21496 fail:
21497 return NULL;
21498 }
21499
21500
21501 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21502 PyObject *resultobj = 0;
21503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21504 int result;
21505 void *argp1 = 0 ;
21506 int res1 = 0 ;
21507 PyObject *swig_obj[1] ;
21508
21509 if (!args) SWIG_fail;
21510 swig_obj[0] = args;
21511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21512 if (!SWIG_IsOK(res1)) {
21513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21514 }
21515 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21516 result = (int) ((arg1)->m_wheelRotation);
21517 resultobj = SWIG_From_int(static_cast< int >(result));
21518 return resultobj;
21519 fail:
21520 return NULL;
21521 }
21522
21523
21524 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21525 PyObject *resultobj = 0;
21526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21527 int arg2 ;
21528 void *argp1 = 0 ;
21529 int res1 = 0 ;
21530 int val2 ;
21531 int ecode2 = 0 ;
21532 PyObject *swig_obj[2] ;
21533
21534 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21536 if (!SWIG_IsOK(res1)) {
21537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21538 }
21539 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21540 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21541 if (!SWIG_IsOK(ecode2)) {
21542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21543 }
21544 arg2 = static_cast< int >(val2);
21545 if (arg1) (arg1)->m_wheelDelta = arg2;
21546
21547 resultobj = SWIG_Py_Void();
21548 return resultobj;
21549 fail:
21550 return NULL;
21551 }
21552
21553
21554 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21555 PyObject *resultobj = 0;
21556 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21557 int result;
21558 void *argp1 = 0 ;
21559 int res1 = 0 ;
21560 PyObject *swig_obj[1] ;
21561
21562 if (!args) SWIG_fail;
21563 swig_obj[0] = args;
21564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21565 if (!SWIG_IsOK(res1)) {
21566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21567 }
21568 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21569 result = (int) ((arg1)->m_wheelDelta);
21570 resultobj = SWIG_From_int(static_cast< int >(result));
21571 return resultobj;
21572 fail:
21573 return NULL;
21574 }
21575
21576
21577 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21578 PyObject *resultobj = 0;
21579 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21580 int arg2 ;
21581 void *argp1 = 0 ;
21582 int res1 = 0 ;
21583 int val2 ;
21584 int ecode2 = 0 ;
21585 PyObject *swig_obj[2] ;
21586
21587 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21589 if (!SWIG_IsOK(res1)) {
21590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21591 }
21592 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21593 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21594 if (!SWIG_IsOK(ecode2)) {
21595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21596 }
21597 arg2 = static_cast< int >(val2);
21598 if (arg1) (arg1)->m_linesPerAction = arg2;
21599
21600 resultobj = SWIG_Py_Void();
21601 return resultobj;
21602 fail:
21603 return NULL;
21604 }
21605
21606
21607 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21608 PyObject *resultobj = 0;
21609 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21610 int result;
21611 void *argp1 = 0 ;
21612 int res1 = 0 ;
21613 PyObject *swig_obj[1] ;
21614
21615 if (!args) SWIG_fail;
21616 swig_obj[0] = args;
21617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21618 if (!SWIG_IsOK(res1)) {
21619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21620 }
21621 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21622 result = (int) ((arg1)->m_linesPerAction);
21623 resultobj = SWIG_From_int(static_cast< int >(result));
21624 return resultobj;
21625 fail:
21626 return NULL;
21627 }
21628
21629
21630 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21631 PyObject *obj;
21632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21633 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21634 return SWIG_Py_Void();
21635 }
21636
21637 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21638 return SWIG_Python_InitShadowInstance(args);
21639 }
21640
21641 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21642 PyObject *resultobj = 0;
21643 int arg1 = (int) 0 ;
21644 int arg2 = (int) 0 ;
21645 wxSetCursorEvent *result = 0 ;
21646 int val1 ;
21647 int ecode1 = 0 ;
21648 int val2 ;
21649 int ecode2 = 0 ;
21650 PyObject * obj0 = 0 ;
21651 PyObject * obj1 = 0 ;
21652 char * kwnames[] = {
21653 (char *) "x",(char *) "y", NULL
21654 };
21655
21656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21657 if (obj0) {
21658 ecode1 = SWIG_AsVal_int(obj0, &val1);
21659 if (!SWIG_IsOK(ecode1)) {
21660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21661 }
21662 arg1 = static_cast< int >(val1);
21663 }
21664 if (obj1) {
21665 ecode2 = SWIG_AsVal_int(obj1, &val2);
21666 if (!SWIG_IsOK(ecode2)) {
21667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21668 }
21669 arg2 = static_cast< int >(val2);
21670 }
21671 {
21672 PyThreadState* __tstate = wxPyBeginAllowThreads();
21673 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21674 wxPyEndAllowThreads(__tstate);
21675 if (PyErr_Occurred()) SWIG_fail;
21676 }
21677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21678 return resultobj;
21679 fail:
21680 return NULL;
21681 }
21682
21683
21684 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21685 PyObject *resultobj = 0;
21686 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21687 int result;
21688 void *argp1 = 0 ;
21689 int res1 = 0 ;
21690 PyObject *swig_obj[1] ;
21691
21692 if (!args) SWIG_fail;
21693 swig_obj[0] = args;
21694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21695 if (!SWIG_IsOK(res1)) {
21696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21697 }
21698 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21699 {
21700 PyThreadState* __tstate = wxPyBeginAllowThreads();
21701 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21702 wxPyEndAllowThreads(__tstate);
21703 if (PyErr_Occurred()) SWIG_fail;
21704 }
21705 resultobj = SWIG_From_int(static_cast< int >(result));
21706 return resultobj;
21707 fail:
21708 return NULL;
21709 }
21710
21711
21712 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21713 PyObject *resultobj = 0;
21714 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21715 int result;
21716 void *argp1 = 0 ;
21717 int res1 = 0 ;
21718 PyObject *swig_obj[1] ;
21719
21720 if (!args) SWIG_fail;
21721 swig_obj[0] = args;
21722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21723 if (!SWIG_IsOK(res1)) {
21724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21725 }
21726 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21727 {
21728 PyThreadState* __tstate = wxPyBeginAllowThreads();
21729 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21730 wxPyEndAllowThreads(__tstate);
21731 if (PyErr_Occurred()) SWIG_fail;
21732 }
21733 resultobj = SWIG_From_int(static_cast< int >(result));
21734 return resultobj;
21735 fail:
21736 return NULL;
21737 }
21738
21739
21740 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21741 PyObject *resultobj = 0;
21742 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21743 wxCursor *arg2 = 0 ;
21744 void *argp1 = 0 ;
21745 int res1 = 0 ;
21746 void *argp2 = 0 ;
21747 int res2 = 0 ;
21748 PyObject * obj0 = 0 ;
21749 PyObject * obj1 = 0 ;
21750 char * kwnames[] = {
21751 (char *) "self",(char *) "cursor", NULL
21752 };
21753
21754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21756 if (!SWIG_IsOK(res1)) {
21757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21758 }
21759 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21760 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21761 if (!SWIG_IsOK(res2)) {
21762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21763 }
21764 if (!argp2) {
21765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21766 }
21767 arg2 = reinterpret_cast< wxCursor * >(argp2);
21768 {
21769 PyThreadState* __tstate = wxPyBeginAllowThreads();
21770 (arg1)->SetCursor((wxCursor const &)*arg2);
21771 wxPyEndAllowThreads(__tstate);
21772 if (PyErr_Occurred()) SWIG_fail;
21773 }
21774 resultobj = SWIG_Py_Void();
21775 return resultobj;
21776 fail:
21777 return NULL;
21778 }
21779
21780
21781 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21782 PyObject *resultobj = 0;
21783 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21784 wxCursor *result = 0 ;
21785 void *argp1 = 0 ;
21786 int res1 = 0 ;
21787 PyObject *swig_obj[1] ;
21788
21789 if (!args) SWIG_fail;
21790 swig_obj[0] = args;
21791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21792 if (!SWIG_IsOK(res1)) {
21793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21794 }
21795 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21796 {
21797 PyThreadState* __tstate = wxPyBeginAllowThreads();
21798 {
21799 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21800 result = (wxCursor *) &_result_ref;
21801 }
21802 wxPyEndAllowThreads(__tstate);
21803 if (PyErr_Occurred()) SWIG_fail;
21804 }
21805 {
21806 wxCursor* resultptr = new wxCursor(*result);
21807 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21808 }
21809 return resultobj;
21810 fail:
21811 return NULL;
21812 }
21813
21814
21815 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21816 PyObject *resultobj = 0;
21817 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21818 bool result;
21819 void *argp1 = 0 ;
21820 int res1 = 0 ;
21821 PyObject *swig_obj[1] ;
21822
21823 if (!args) SWIG_fail;
21824 swig_obj[0] = args;
21825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21826 if (!SWIG_IsOK(res1)) {
21827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21828 }
21829 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21830 {
21831 PyThreadState* __tstate = wxPyBeginAllowThreads();
21832 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21833 wxPyEndAllowThreads(__tstate);
21834 if (PyErr_Occurred()) SWIG_fail;
21835 }
21836 {
21837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21838 }
21839 return resultobj;
21840 fail:
21841 return NULL;
21842 }
21843
21844
21845 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21846 PyObject *obj;
21847 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21848 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21849 return SWIG_Py_Void();
21850 }
21851
21852 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21853 return SWIG_Python_InitShadowInstance(args);
21854 }
21855
21856 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21857 PyObject *resultobj = 0;
21858 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21859 wxKeyEvent *result = 0 ;
21860 int val1 ;
21861 int ecode1 = 0 ;
21862 PyObject * obj0 = 0 ;
21863 char * kwnames[] = {
21864 (char *) "eventType", NULL
21865 };
21866
21867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21868 if (obj0) {
21869 ecode1 = SWIG_AsVal_int(obj0, &val1);
21870 if (!SWIG_IsOK(ecode1)) {
21871 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21872 }
21873 arg1 = static_cast< wxEventType >(val1);
21874 }
21875 {
21876 PyThreadState* __tstate = wxPyBeginAllowThreads();
21877 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21878 wxPyEndAllowThreads(__tstate);
21879 if (PyErr_Occurred()) SWIG_fail;
21880 }
21881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21882 return resultobj;
21883 fail:
21884 return NULL;
21885 }
21886
21887
21888 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21889 PyObject *resultobj = 0;
21890 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21891 int result;
21892 void *argp1 = 0 ;
21893 int res1 = 0 ;
21894 PyObject *swig_obj[1] ;
21895
21896 if (!args) SWIG_fail;
21897 swig_obj[0] = args;
21898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21899 if (!SWIG_IsOK(res1)) {
21900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21901 }
21902 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21903 {
21904 PyThreadState* __tstate = wxPyBeginAllowThreads();
21905 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21906 wxPyEndAllowThreads(__tstate);
21907 if (PyErr_Occurred()) SWIG_fail;
21908 }
21909 resultobj = SWIG_From_int(static_cast< int >(result));
21910 return resultobj;
21911 fail:
21912 return NULL;
21913 }
21914
21915
21916 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21917 PyObject *resultobj = 0;
21918 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21919 bool result;
21920 void *argp1 = 0 ;
21921 int res1 = 0 ;
21922 PyObject *swig_obj[1] ;
21923
21924 if (!args) SWIG_fail;
21925 swig_obj[0] = args;
21926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21927 if (!SWIG_IsOK(res1)) {
21928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21929 }
21930 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21931 {
21932 PyThreadState* __tstate = wxPyBeginAllowThreads();
21933 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 {
21938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21939 }
21940 return resultobj;
21941 fail:
21942 return NULL;
21943 }
21944
21945
21946 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21947 PyObject *resultobj = 0;
21948 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21949 bool result;
21950 void *argp1 = 0 ;
21951 int res1 = 0 ;
21952 PyObject *swig_obj[1] ;
21953
21954 if (!args) SWIG_fail;
21955 swig_obj[0] = args;
21956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21957 if (!SWIG_IsOK(res1)) {
21958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21959 }
21960 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21961 {
21962 PyThreadState* __tstate = wxPyBeginAllowThreads();
21963 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21964 wxPyEndAllowThreads(__tstate);
21965 if (PyErr_Occurred()) SWIG_fail;
21966 }
21967 {
21968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21969 }
21970 return resultobj;
21971 fail:
21972 return NULL;
21973 }
21974
21975
21976 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21977 PyObject *resultobj = 0;
21978 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21979 bool result;
21980 void *argp1 = 0 ;
21981 int res1 = 0 ;
21982 PyObject *swig_obj[1] ;
21983
21984 if (!args) SWIG_fail;
21985 swig_obj[0] = args;
21986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21987 if (!SWIG_IsOK(res1)) {
21988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21989 }
21990 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21991 {
21992 PyThreadState* __tstate = wxPyBeginAllowThreads();
21993 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21994 wxPyEndAllowThreads(__tstate);
21995 if (PyErr_Occurred()) SWIG_fail;
21996 }
21997 {
21998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21999 }
22000 return resultobj;
22001 fail:
22002 return NULL;
22003 }
22004
22005
22006 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22007 PyObject *resultobj = 0;
22008 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22009 bool result;
22010 void *argp1 = 0 ;
22011 int res1 = 0 ;
22012 PyObject *swig_obj[1] ;
22013
22014 if (!args) SWIG_fail;
22015 swig_obj[0] = args;
22016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22017 if (!SWIG_IsOK(res1)) {
22018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22019 }
22020 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22021 {
22022 PyThreadState* __tstate = wxPyBeginAllowThreads();
22023 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22024 wxPyEndAllowThreads(__tstate);
22025 if (PyErr_Occurred()) SWIG_fail;
22026 }
22027 {
22028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22029 }
22030 return resultobj;
22031 fail:
22032 return NULL;
22033 }
22034
22035
22036 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22037 PyObject *resultobj = 0;
22038 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22039 bool result;
22040 void *argp1 = 0 ;
22041 int res1 = 0 ;
22042 PyObject *swig_obj[1] ;
22043
22044 if (!args) SWIG_fail;
22045 swig_obj[0] = args;
22046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22047 if (!SWIG_IsOK(res1)) {
22048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22049 }
22050 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22051 {
22052 PyThreadState* __tstate = wxPyBeginAllowThreads();
22053 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22054 wxPyEndAllowThreads(__tstate);
22055 if (PyErr_Occurred()) SWIG_fail;
22056 }
22057 {
22058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22059 }
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22067 PyObject *resultobj = 0;
22068 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22069 bool result;
22070 void *argp1 = 0 ;
22071 int res1 = 0 ;
22072 PyObject *swig_obj[1] ;
22073
22074 if (!args) SWIG_fail;
22075 swig_obj[0] = args;
22076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22079 }
22080 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22081 {
22082 PyThreadState* __tstate = wxPyBeginAllowThreads();
22083 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22084 wxPyEndAllowThreads(__tstate);
22085 if (PyErr_Occurred()) SWIG_fail;
22086 }
22087 {
22088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22089 }
22090 return resultobj;
22091 fail:
22092 return NULL;
22093 }
22094
22095
22096 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22097 PyObject *resultobj = 0;
22098 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22099 int result;
22100 void *argp1 = 0 ;
22101 int res1 = 0 ;
22102 PyObject *swig_obj[1] ;
22103
22104 if (!args) SWIG_fail;
22105 swig_obj[0] = args;
22106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22107 if (!SWIG_IsOK(res1)) {
22108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22109 }
22110 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22111 {
22112 PyThreadState* __tstate = wxPyBeginAllowThreads();
22113 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22114 wxPyEndAllowThreads(__tstate);
22115 if (PyErr_Occurred()) SWIG_fail;
22116 }
22117 resultobj = SWIG_From_int(static_cast< int >(result));
22118 return resultobj;
22119 fail:
22120 return NULL;
22121 }
22122
22123
22124 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22125 PyObject *resultobj = 0;
22126 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22127 int result;
22128 void *argp1 = 0 ;
22129 int res1 = 0 ;
22130 PyObject *swig_obj[1] ;
22131
22132 if (!args) SWIG_fail;
22133 swig_obj[0] = args;
22134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22135 if (!SWIG_IsOK(res1)) {
22136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22137 }
22138 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22139 {
22140 PyThreadState* __tstate = wxPyBeginAllowThreads();
22141 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22142 wxPyEndAllowThreads(__tstate);
22143 if (PyErr_Occurred()) SWIG_fail;
22144 }
22145 resultobj = SWIG_From_int(static_cast< int >(result));
22146 return resultobj;
22147 fail:
22148 return NULL;
22149 }
22150
22151
22152 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22153 PyObject *resultobj = 0;
22154 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22155 unsigned int result;
22156 void *argp1 = 0 ;
22157 int res1 = 0 ;
22158 PyObject *swig_obj[1] ;
22159
22160 if (!args) SWIG_fail;
22161 swig_obj[0] = args;
22162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22163 if (!SWIG_IsOK(res1)) {
22164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22165 }
22166 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22167 {
22168 PyThreadState* __tstate = wxPyBeginAllowThreads();
22169 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22170 wxPyEndAllowThreads(__tstate);
22171 if (PyErr_Occurred()) SWIG_fail;
22172 }
22173 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22174 return resultobj;
22175 fail:
22176 return NULL;
22177 }
22178
22179
22180 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22181 PyObject *resultobj = 0;
22182 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22183 unsigned int result;
22184 void *argp1 = 0 ;
22185 int res1 = 0 ;
22186 PyObject *swig_obj[1] ;
22187
22188 if (!args) SWIG_fail;
22189 swig_obj[0] = args;
22190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22191 if (!SWIG_IsOK(res1)) {
22192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22193 }
22194 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22195 {
22196 PyThreadState* __tstate = wxPyBeginAllowThreads();
22197 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22198 wxPyEndAllowThreads(__tstate);
22199 if (PyErr_Occurred()) SWIG_fail;
22200 }
22201 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22202 return resultobj;
22203 fail:
22204 return NULL;
22205 }
22206
22207
22208 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22209 PyObject *resultobj = 0;
22210 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22211 wxPoint result;
22212 void *argp1 = 0 ;
22213 int res1 = 0 ;
22214 PyObject *swig_obj[1] ;
22215
22216 if (!args) SWIG_fail;
22217 swig_obj[0] = args;
22218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22219 if (!SWIG_IsOK(res1)) {
22220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22221 }
22222 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22223 {
22224 PyThreadState* __tstate = wxPyBeginAllowThreads();
22225 result = (arg1)->GetPosition();
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22237 PyObject *resultobj = 0;
22238 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22239 long *arg2 = (long *) 0 ;
22240 long *arg3 = (long *) 0 ;
22241 void *argp1 = 0 ;
22242 int res1 = 0 ;
22243 long temp2 ;
22244 int res2 = SWIG_TMPOBJ ;
22245 long temp3 ;
22246 int res3 = SWIG_TMPOBJ ;
22247 PyObject *swig_obj[1] ;
22248
22249 arg2 = &temp2;
22250 arg3 = &temp3;
22251 if (!args) SWIG_fail;
22252 swig_obj[0] = args;
22253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22254 if (!SWIG_IsOK(res1)) {
22255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22256 }
22257 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22258 {
22259 PyThreadState* __tstate = wxPyBeginAllowThreads();
22260 (arg1)->GetPosition(arg2,arg3);
22261 wxPyEndAllowThreads(__tstate);
22262 if (PyErr_Occurred()) SWIG_fail;
22263 }
22264 resultobj = SWIG_Py_Void();
22265 if (SWIG_IsTmpObj(res2)) {
22266 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22267 } else {
22268 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22269 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22270 }
22271 if (SWIG_IsTmpObj(res3)) {
22272 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22273 } else {
22274 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22275 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22276 }
22277 return resultobj;
22278 fail:
22279 return NULL;
22280 }
22281
22282
22283 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22284 PyObject *resultobj = 0;
22285 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22286 int result;
22287 void *argp1 = 0 ;
22288 int res1 = 0 ;
22289 PyObject *swig_obj[1] ;
22290
22291 if (!args) SWIG_fail;
22292 swig_obj[0] = args;
22293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22294 if (!SWIG_IsOK(res1)) {
22295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22296 }
22297 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22298 {
22299 PyThreadState* __tstate = wxPyBeginAllowThreads();
22300 result = (int)((wxKeyEvent const *)arg1)->GetX();
22301 wxPyEndAllowThreads(__tstate);
22302 if (PyErr_Occurred()) SWIG_fail;
22303 }
22304 resultobj = SWIG_From_int(static_cast< int >(result));
22305 return resultobj;
22306 fail:
22307 return NULL;
22308 }
22309
22310
22311 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22312 PyObject *resultobj = 0;
22313 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22314 int result;
22315 void *argp1 = 0 ;
22316 int res1 = 0 ;
22317 PyObject *swig_obj[1] ;
22318
22319 if (!args) SWIG_fail;
22320 swig_obj[0] = args;
22321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22322 if (!SWIG_IsOK(res1)) {
22323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22324 }
22325 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22326 {
22327 PyThreadState* __tstate = wxPyBeginAllowThreads();
22328 result = (int)((wxKeyEvent const *)arg1)->GetY();
22329 wxPyEndAllowThreads(__tstate);
22330 if (PyErr_Occurred()) SWIG_fail;
22331 }
22332 resultobj = SWIG_From_int(static_cast< int >(result));
22333 return resultobj;
22334 fail:
22335 return NULL;
22336 }
22337
22338
22339 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22340 PyObject *resultobj = 0;
22341 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22342 int arg2 ;
22343 void *argp1 = 0 ;
22344 int res1 = 0 ;
22345 int val2 ;
22346 int ecode2 = 0 ;
22347 PyObject *swig_obj[2] ;
22348
22349 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22351 if (!SWIG_IsOK(res1)) {
22352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22353 }
22354 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22355 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22356 if (!SWIG_IsOK(ecode2)) {
22357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22358 }
22359 arg2 = static_cast< int >(val2);
22360 if (arg1) (arg1)->m_x = arg2;
22361
22362 resultobj = SWIG_Py_Void();
22363 return resultobj;
22364 fail:
22365 return NULL;
22366 }
22367
22368
22369 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22370 PyObject *resultobj = 0;
22371 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22372 int result;
22373 void *argp1 = 0 ;
22374 int res1 = 0 ;
22375 PyObject *swig_obj[1] ;
22376
22377 if (!args) SWIG_fail;
22378 swig_obj[0] = args;
22379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22380 if (!SWIG_IsOK(res1)) {
22381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22382 }
22383 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22384 result = (int) ((arg1)->m_x);
22385 resultobj = SWIG_From_int(static_cast< int >(result));
22386 return resultobj;
22387 fail:
22388 return NULL;
22389 }
22390
22391
22392 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22393 PyObject *resultobj = 0;
22394 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22395 int arg2 ;
22396 void *argp1 = 0 ;
22397 int res1 = 0 ;
22398 int val2 ;
22399 int ecode2 = 0 ;
22400 PyObject *swig_obj[2] ;
22401
22402 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22404 if (!SWIG_IsOK(res1)) {
22405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22406 }
22407 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22408 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22409 if (!SWIG_IsOK(ecode2)) {
22410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22411 }
22412 arg2 = static_cast< int >(val2);
22413 if (arg1) (arg1)->m_y = arg2;
22414
22415 resultobj = SWIG_Py_Void();
22416 return resultobj;
22417 fail:
22418 return NULL;
22419 }
22420
22421
22422 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22423 PyObject *resultobj = 0;
22424 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22425 int result;
22426 void *argp1 = 0 ;
22427 int res1 = 0 ;
22428 PyObject *swig_obj[1] ;
22429
22430 if (!args) SWIG_fail;
22431 swig_obj[0] = args;
22432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22433 if (!SWIG_IsOK(res1)) {
22434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22435 }
22436 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22437 result = (int) ((arg1)->m_y);
22438 resultobj = SWIG_From_int(static_cast< int >(result));
22439 return resultobj;
22440 fail:
22441 return NULL;
22442 }
22443
22444
22445 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22446 PyObject *resultobj = 0;
22447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22448 long arg2 ;
22449 void *argp1 = 0 ;
22450 int res1 = 0 ;
22451 long val2 ;
22452 int ecode2 = 0 ;
22453 PyObject *swig_obj[2] ;
22454
22455 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22457 if (!SWIG_IsOK(res1)) {
22458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22459 }
22460 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22461 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22462 if (!SWIG_IsOK(ecode2)) {
22463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22464 }
22465 arg2 = static_cast< long >(val2);
22466 if (arg1) (arg1)->m_keyCode = arg2;
22467
22468 resultobj = SWIG_Py_Void();
22469 return resultobj;
22470 fail:
22471 return NULL;
22472 }
22473
22474
22475 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22476 PyObject *resultobj = 0;
22477 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22478 long result;
22479 void *argp1 = 0 ;
22480 int res1 = 0 ;
22481 PyObject *swig_obj[1] ;
22482
22483 if (!args) SWIG_fail;
22484 swig_obj[0] = args;
22485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22486 if (!SWIG_IsOK(res1)) {
22487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22488 }
22489 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22490 result = (long) ((arg1)->m_keyCode);
22491 resultobj = SWIG_From_long(static_cast< long >(result));
22492 return resultobj;
22493 fail:
22494 return NULL;
22495 }
22496
22497
22498 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22499 PyObject *resultobj = 0;
22500 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22501 bool arg2 ;
22502 void *argp1 = 0 ;
22503 int res1 = 0 ;
22504 bool val2 ;
22505 int ecode2 = 0 ;
22506 PyObject *swig_obj[2] ;
22507
22508 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22510 if (!SWIG_IsOK(res1)) {
22511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22512 }
22513 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22514 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22515 if (!SWIG_IsOK(ecode2)) {
22516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22517 }
22518 arg2 = static_cast< bool >(val2);
22519 if (arg1) (arg1)->m_controlDown = arg2;
22520
22521 resultobj = SWIG_Py_Void();
22522 return resultobj;
22523 fail:
22524 return NULL;
22525 }
22526
22527
22528 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22529 PyObject *resultobj = 0;
22530 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22531 bool result;
22532 void *argp1 = 0 ;
22533 int res1 = 0 ;
22534 PyObject *swig_obj[1] ;
22535
22536 if (!args) SWIG_fail;
22537 swig_obj[0] = args;
22538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22539 if (!SWIG_IsOK(res1)) {
22540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22541 }
22542 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22543 result = (bool) ((arg1)->m_controlDown);
22544 {
22545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22546 }
22547 return resultobj;
22548 fail:
22549 return NULL;
22550 }
22551
22552
22553 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22554 PyObject *resultobj = 0;
22555 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22556 bool arg2 ;
22557 void *argp1 = 0 ;
22558 int res1 = 0 ;
22559 bool val2 ;
22560 int ecode2 = 0 ;
22561 PyObject *swig_obj[2] ;
22562
22563 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22565 if (!SWIG_IsOK(res1)) {
22566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22567 }
22568 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22569 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22570 if (!SWIG_IsOK(ecode2)) {
22571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22572 }
22573 arg2 = static_cast< bool >(val2);
22574 if (arg1) (arg1)->m_shiftDown = arg2;
22575
22576 resultobj = SWIG_Py_Void();
22577 return resultobj;
22578 fail:
22579 return NULL;
22580 }
22581
22582
22583 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22584 PyObject *resultobj = 0;
22585 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22586 bool result;
22587 void *argp1 = 0 ;
22588 int res1 = 0 ;
22589 PyObject *swig_obj[1] ;
22590
22591 if (!args) SWIG_fail;
22592 swig_obj[0] = args;
22593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22594 if (!SWIG_IsOK(res1)) {
22595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22596 }
22597 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22598 result = (bool) ((arg1)->m_shiftDown);
22599 {
22600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22601 }
22602 return resultobj;
22603 fail:
22604 return NULL;
22605 }
22606
22607
22608 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22609 PyObject *resultobj = 0;
22610 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22611 bool arg2 ;
22612 void *argp1 = 0 ;
22613 int res1 = 0 ;
22614 bool val2 ;
22615 int ecode2 = 0 ;
22616 PyObject *swig_obj[2] ;
22617
22618 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22620 if (!SWIG_IsOK(res1)) {
22621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22622 }
22623 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22624 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22625 if (!SWIG_IsOK(ecode2)) {
22626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22627 }
22628 arg2 = static_cast< bool >(val2);
22629 if (arg1) (arg1)->m_altDown = arg2;
22630
22631 resultobj = SWIG_Py_Void();
22632 return resultobj;
22633 fail:
22634 return NULL;
22635 }
22636
22637
22638 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22639 PyObject *resultobj = 0;
22640 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22641 bool result;
22642 void *argp1 = 0 ;
22643 int res1 = 0 ;
22644 PyObject *swig_obj[1] ;
22645
22646 if (!args) SWIG_fail;
22647 swig_obj[0] = args;
22648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22649 if (!SWIG_IsOK(res1)) {
22650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22651 }
22652 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22653 result = (bool) ((arg1)->m_altDown);
22654 {
22655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22656 }
22657 return resultobj;
22658 fail:
22659 return NULL;
22660 }
22661
22662
22663 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22664 PyObject *resultobj = 0;
22665 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22666 bool arg2 ;
22667 void *argp1 = 0 ;
22668 int res1 = 0 ;
22669 bool val2 ;
22670 int ecode2 = 0 ;
22671 PyObject *swig_obj[2] ;
22672
22673 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22675 if (!SWIG_IsOK(res1)) {
22676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22677 }
22678 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22679 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22680 if (!SWIG_IsOK(ecode2)) {
22681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22682 }
22683 arg2 = static_cast< bool >(val2);
22684 if (arg1) (arg1)->m_metaDown = arg2;
22685
22686 resultobj = SWIG_Py_Void();
22687 return resultobj;
22688 fail:
22689 return NULL;
22690 }
22691
22692
22693 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22694 PyObject *resultobj = 0;
22695 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22696 bool result;
22697 void *argp1 = 0 ;
22698 int res1 = 0 ;
22699 PyObject *swig_obj[1] ;
22700
22701 if (!args) SWIG_fail;
22702 swig_obj[0] = args;
22703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22704 if (!SWIG_IsOK(res1)) {
22705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22706 }
22707 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22708 result = (bool) ((arg1)->m_metaDown);
22709 {
22710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22711 }
22712 return resultobj;
22713 fail:
22714 return NULL;
22715 }
22716
22717
22718 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22719 PyObject *resultobj = 0;
22720 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22721 bool arg2 ;
22722 void *argp1 = 0 ;
22723 int res1 = 0 ;
22724 bool val2 ;
22725 int ecode2 = 0 ;
22726 PyObject *swig_obj[2] ;
22727
22728 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22730 if (!SWIG_IsOK(res1)) {
22731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22732 }
22733 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22734 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22735 if (!SWIG_IsOK(ecode2)) {
22736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22737 }
22738 arg2 = static_cast< bool >(val2);
22739 if (arg1) (arg1)->m_scanCode = arg2;
22740
22741 resultobj = SWIG_Py_Void();
22742 return resultobj;
22743 fail:
22744 return NULL;
22745 }
22746
22747
22748 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22749 PyObject *resultobj = 0;
22750 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22751 bool result;
22752 void *argp1 = 0 ;
22753 int res1 = 0 ;
22754 PyObject *swig_obj[1] ;
22755
22756 if (!args) SWIG_fail;
22757 swig_obj[0] = args;
22758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22759 if (!SWIG_IsOK(res1)) {
22760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22761 }
22762 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22763 result = (bool) ((arg1)->m_scanCode);
22764 {
22765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22766 }
22767 return resultobj;
22768 fail:
22769 return NULL;
22770 }
22771
22772
22773 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22774 PyObject *resultobj = 0;
22775 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22776 unsigned int arg2 ;
22777 void *argp1 = 0 ;
22778 int res1 = 0 ;
22779 unsigned int val2 ;
22780 int ecode2 = 0 ;
22781 PyObject *swig_obj[2] ;
22782
22783 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22785 if (!SWIG_IsOK(res1)) {
22786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22787 }
22788 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22789 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22790 if (!SWIG_IsOK(ecode2)) {
22791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22792 }
22793 arg2 = static_cast< unsigned int >(val2);
22794 if (arg1) (arg1)->m_rawCode = arg2;
22795
22796 resultobj = SWIG_Py_Void();
22797 return resultobj;
22798 fail:
22799 return NULL;
22800 }
22801
22802
22803 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22804 PyObject *resultobj = 0;
22805 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22806 unsigned int result;
22807 void *argp1 = 0 ;
22808 int res1 = 0 ;
22809 PyObject *swig_obj[1] ;
22810
22811 if (!args) SWIG_fail;
22812 swig_obj[0] = args;
22813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22814 if (!SWIG_IsOK(res1)) {
22815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22816 }
22817 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22818 result = (unsigned int) ((arg1)->m_rawCode);
22819 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22820 return resultobj;
22821 fail:
22822 return NULL;
22823 }
22824
22825
22826 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22827 PyObject *resultobj = 0;
22828 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22829 unsigned int arg2 ;
22830 void *argp1 = 0 ;
22831 int res1 = 0 ;
22832 unsigned int val2 ;
22833 int ecode2 = 0 ;
22834 PyObject *swig_obj[2] ;
22835
22836 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22838 if (!SWIG_IsOK(res1)) {
22839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22840 }
22841 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22842 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22843 if (!SWIG_IsOK(ecode2)) {
22844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22845 }
22846 arg2 = static_cast< unsigned int >(val2);
22847 if (arg1) (arg1)->m_rawFlags = arg2;
22848
22849 resultobj = SWIG_Py_Void();
22850 return resultobj;
22851 fail:
22852 return NULL;
22853 }
22854
22855
22856 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22857 PyObject *resultobj = 0;
22858 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22859 unsigned int result;
22860 void *argp1 = 0 ;
22861 int res1 = 0 ;
22862 PyObject *swig_obj[1] ;
22863
22864 if (!args) SWIG_fail;
22865 swig_obj[0] = args;
22866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22867 if (!SWIG_IsOK(res1)) {
22868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22869 }
22870 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22871 result = (unsigned int) ((arg1)->m_rawFlags);
22872 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22873 return resultobj;
22874 fail:
22875 return NULL;
22876 }
22877
22878
22879 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22880 PyObject *obj;
22881 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22882 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22883 return SWIG_Py_Void();
22884 }
22885
22886 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22887 return SWIG_Python_InitShadowInstance(args);
22888 }
22889
22890 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22891 PyObject *resultobj = 0;
22892 wxSize const &arg1_defvalue = wxDefaultSize ;
22893 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22894 int arg2 = (int) 0 ;
22895 wxSizeEvent *result = 0 ;
22896 wxSize temp1 ;
22897 int val2 ;
22898 int ecode2 = 0 ;
22899 PyObject * obj0 = 0 ;
22900 PyObject * obj1 = 0 ;
22901 char * kwnames[] = {
22902 (char *) "sz",(char *) "winid", NULL
22903 };
22904
22905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22906 if (obj0) {
22907 {
22908 arg1 = &temp1;
22909 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22910 }
22911 }
22912 if (obj1) {
22913 ecode2 = SWIG_AsVal_int(obj1, &val2);
22914 if (!SWIG_IsOK(ecode2)) {
22915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22916 }
22917 arg2 = static_cast< int >(val2);
22918 }
22919 {
22920 PyThreadState* __tstate = wxPyBeginAllowThreads();
22921 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22922 wxPyEndAllowThreads(__tstate);
22923 if (PyErr_Occurred()) SWIG_fail;
22924 }
22925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22926 return resultobj;
22927 fail:
22928 return NULL;
22929 }
22930
22931
22932 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22933 PyObject *resultobj = 0;
22934 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22935 wxSize result;
22936 void *argp1 = 0 ;
22937 int res1 = 0 ;
22938 PyObject *swig_obj[1] ;
22939
22940 if (!args) SWIG_fail;
22941 swig_obj[0] = args;
22942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22943 if (!SWIG_IsOK(res1)) {
22944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22945 }
22946 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22947 {
22948 PyThreadState* __tstate = wxPyBeginAllowThreads();
22949 result = ((wxSizeEvent const *)arg1)->GetSize();
22950 wxPyEndAllowThreads(__tstate);
22951 if (PyErr_Occurred()) SWIG_fail;
22952 }
22953 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22954 return resultobj;
22955 fail:
22956 return NULL;
22957 }
22958
22959
22960 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22961 PyObject *resultobj = 0;
22962 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22963 wxRect result;
22964 void *argp1 = 0 ;
22965 int res1 = 0 ;
22966 PyObject *swig_obj[1] ;
22967
22968 if (!args) SWIG_fail;
22969 swig_obj[0] = args;
22970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22971 if (!SWIG_IsOK(res1)) {
22972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22973 }
22974 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22975 {
22976 PyThreadState* __tstate = wxPyBeginAllowThreads();
22977 result = ((wxSizeEvent const *)arg1)->GetRect();
22978 wxPyEndAllowThreads(__tstate);
22979 if (PyErr_Occurred()) SWIG_fail;
22980 }
22981 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22982 return resultobj;
22983 fail:
22984 return NULL;
22985 }
22986
22987
22988 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22989 PyObject *resultobj = 0;
22990 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22991 wxRect arg2 ;
22992 void *argp1 = 0 ;
22993 int res1 = 0 ;
22994 void *argp2 ;
22995 int res2 = 0 ;
22996 PyObject * obj0 = 0 ;
22997 PyObject * obj1 = 0 ;
22998 char * kwnames[] = {
22999 (char *) "self",(char *) "rect", NULL
23000 };
23001
23002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23004 if (!SWIG_IsOK(res1)) {
23005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23006 }
23007 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23008 {
23009 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23010 if (!SWIG_IsOK(res2)) {
23011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23012 }
23013 if (!argp2) {
23014 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23015 } else {
23016 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23017 arg2 = *temp;
23018 if (SWIG_IsNewObj(res2)) delete temp;
23019 }
23020 }
23021 {
23022 PyThreadState* __tstate = wxPyBeginAllowThreads();
23023 (arg1)->SetRect(arg2);
23024 wxPyEndAllowThreads(__tstate);
23025 if (PyErr_Occurred()) SWIG_fail;
23026 }
23027 resultobj = SWIG_Py_Void();
23028 return resultobj;
23029 fail:
23030 return NULL;
23031 }
23032
23033
23034 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23035 PyObject *resultobj = 0;
23036 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23037 wxSize arg2 ;
23038 void *argp1 = 0 ;
23039 int res1 = 0 ;
23040 void *argp2 ;
23041 int res2 = 0 ;
23042 PyObject * obj0 = 0 ;
23043 PyObject * obj1 = 0 ;
23044 char * kwnames[] = {
23045 (char *) "self",(char *) "size", NULL
23046 };
23047
23048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23050 if (!SWIG_IsOK(res1)) {
23051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23052 }
23053 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23054 {
23055 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23056 if (!SWIG_IsOK(res2)) {
23057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23058 }
23059 if (!argp2) {
23060 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23061 } else {
23062 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23063 arg2 = *temp;
23064 if (SWIG_IsNewObj(res2)) delete temp;
23065 }
23066 }
23067 {
23068 PyThreadState* __tstate = wxPyBeginAllowThreads();
23069 wxSizeEvent_SetSize(arg1,arg2);
23070 wxPyEndAllowThreads(__tstate);
23071 if (PyErr_Occurred()) SWIG_fail;
23072 }
23073 resultobj = SWIG_Py_Void();
23074 return resultobj;
23075 fail:
23076 return NULL;
23077 }
23078
23079
23080 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23081 PyObject *resultobj = 0;
23082 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23083 wxSize *arg2 = (wxSize *) 0 ;
23084 void *argp1 = 0 ;
23085 int res1 = 0 ;
23086 void *argp2 = 0 ;
23087 int res2 = 0 ;
23088 PyObject *swig_obj[2] ;
23089
23090 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23092 if (!SWIG_IsOK(res1)) {
23093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23094 }
23095 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23096 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23097 if (!SWIG_IsOK(res2)) {
23098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23099 }
23100 arg2 = reinterpret_cast< wxSize * >(argp2);
23101 if (arg1) (arg1)->m_size = *arg2;
23102
23103 resultobj = SWIG_Py_Void();
23104 return resultobj;
23105 fail:
23106 return NULL;
23107 }
23108
23109
23110 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23111 PyObject *resultobj = 0;
23112 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23113 wxSize *result = 0 ;
23114 void *argp1 = 0 ;
23115 int res1 = 0 ;
23116 PyObject *swig_obj[1] ;
23117
23118 if (!args) SWIG_fail;
23119 swig_obj[0] = args;
23120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23121 if (!SWIG_IsOK(res1)) {
23122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23123 }
23124 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23125 result = (wxSize *)& ((arg1)->m_size);
23126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23127 return resultobj;
23128 fail:
23129 return NULL;
23130 }
23131
23132
23133 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23134 PyObject *resultobj = 0;
23135 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23136 wxRect *arg2 = (wxRect *) 0 ;
23137 void *argp1 = 0 ;
23138 int res1 = 0 ;
23139 void *argp2 = 0 ;
23140 int res2 = 0 ;
23141 PyObject *swig_obj[2] ;
23142
23143 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23145 if (!SWIG_IsOK(res1)) {
23146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23147 }
23148 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23149 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23150 if (!SWIG_IsOK(res2)) {
23151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23152 }
23153 arg2 = reinterpret_cast< wxRect * >(argp2);
23154 if (arg1) (arg1)->m_rect = *arg2;
23155
23156 resultobj = SWIG_Py_Void();
23157 return resultobj;
23158 fail:
23159 return NULL;
23160 }
23161
23162
23163 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23164 PyObject *resultobj = 0;
23165 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23166 wxRect *result = 0 ;
23167 void *argp1 = 0 ;
23168 int res1 = 0 ;
23169 PyObject *swig_obj[1] ;
23170
23171 if (!args) SWIG_fail;
23172 swig_obj[0] = args;
23173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23174 if (!SWIG_IsOK(res1)) {
23175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23176 }
23177 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23178 result = (wxRect *)& ((arg1)->m_rect);
23179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23180 return resultobj;
23181 fail:
23182 return NULL;
23183 }
23184
23185
23186 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23187 PyObject *obj;
23188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23189 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23190 return SWIG_Py_Void();
23191 }
23192
23193 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23194 return SWIG_Python_InitShadowInstance(args);
23195 }
23196
23197 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23198 PyObject *resultobj = 0;
23199 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23200 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23201 int arg2 = (int) 0 ;
23202 wxMoveEvent *result = 0 ;
23203 wxPoint temp1 ;
23204 int val2 ;
23205 int ecode2 = 0 ;
23206 PyObject * obj0 = 0 ;
23207 PyObject * obj1 = 0 ;
23208 char * kwnames[] = {
23209 (char *) "pos",(char *) "winid", NULL
23210 };
23211
23212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23213 if (obj0) {
23214 {
23215 arg1 = &temp1;
23216 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23217 }
23218 }
23219 if (obj1) {
23220 ecode2 = SWIG_AsVal_int(obj1, &val2);
23221 if (!SWIG_IsOK(ecode2)) {
23222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23223 }
23224 arg2 = static_cast< int >(val2);
23225 }
23226 {
23227 PyThreadState* __tstate = wxPyBeginAllowThreads();
23228 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23229 wxPyEndAllowThreads(__tstate);
23230 if (PyErr_Occurred()) SWIG_fail;
23231 }
23232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23233 return resultobj;
23234 fail:
23235 return NULL;
23236 }
23237
23238
23239 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23240 PyObject *resultobj = 0;
23241 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23242 wxPoint result;
23243 void *argp1 = 0 ;
23244 int res1 = 0 ;
23245 PyObject *swig_obj[1] ;
23246
23247 if (!args) SWIG_fail;
23248 swig_obj[0] = args;
23249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23250 if (!SWIG_IsOK(res1)) {
23251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23252 }
23253 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23254 {
23255 PyThreadState* __tstate = wxPyBeginAllowThreads();
23256 result = ((wxMoveEvent const *)arg1)->GetPosition();
23257 wxPyEndAllowThreads(__tstate);
23258 if (PyErr_Occurred()) SWIG_fail;
23259 }
23260 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23261 return resultobj;
23262 fail:
23263 return NULL;
23264 }
23265
23266
23267 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23268 PyObject *resultobj = 0;
23269 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23270 wxRect result;
23271 void *argp1 = 0 ;
23272 int res1 = 0 ;
23273 PyObject *swig_obj[1] ;
23274
23275 if (!args) SWIG_fail;
23276 swig_obj[0] = args;
23277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23278 if (!SWIG_IsOK(res1)) {
23279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23280 }
23281 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23282 {
23283 PyThreadState* __tstate = wxPyBeginAllowThreads();
23284 result = ((wxMoveEvent const *)arg1)->GetRect();
23285 wxPyEndAllowThreads(__tstate);
23286 if (PyErr_Occurred()) SWIG_fail;
23287 }
23288 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23289 return resultobj;
23290 fail:
23291 return NULL;
23292 }
23293
23294
23295 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23296 PyObject *resultobj = 0;
23297 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23298 wxRect *arg2 = 0 ;
23299 void *argp1 = 0 ;
23300 int res1 = 0 ;
23301 wxRect temp2 ;
23302 PyObject * obj0 = 0 ;
23303 PyObject * obj1 = 0 ;
23304 char * kwnames[] = {
23305 (char *) "self",(char *) "rect", NULL
23306 };
23307
23308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23310 if (!SWIG_IsOK(res1)) {
23311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23312 }
23313 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23314 {
23315 arg2 = &temp2;
23316 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23317 }
23318 {
23319 PyThreadState* __tstate = wxPyBeginAllowThreads();
23320 (arg1)->SetRect((wxRect const &)*arg2);
23321 wxPyEndAllowThreads(__tstate);
23322 if (PyErr_Occurred()) SWIG_fail;
23323 }
23324 resultobj = SWIG_Py_Void();
23325 return resultobj;
23326 fail:
23327 return NULL;
23328 }
23329
23330
23331 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23332 PyObject *resultobj = 0;
23333 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23334 wxPoint *arg2 = 0 ;
23335 void *argp1 = 0 ;
23336 int res1 = 0 ;
23337 wxPoint temp2 ;
23338 PyObject * obj0 = 0 ;
23339 PyObject * obj1 = 0 ;
23340 char * kwnames[] = {
23341 (char *) "self",(char *) "pos", NULL
23342 };
23343
23344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23346 if (!SWIG_IsOK(res1)) {
23347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23348 }
23349 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23350 {
23351 arg2 = &temp2;
23352 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23353 }
23354 {
23355 PyThreadState* __tstate = wxPyBeginAllowThreads();
23356 (arg1)->SetPosition((wxPoint const &)*arg2);
23357 wxPyEndAllowThreads(__tstate);
23358 if (PyErr_Occurred()) SWIG_fail;
23359 }
23360 resultobj = SWIG_Py_Void();
23361 return resultobj;
23362 fail:
23363 return NULL;
23364 }
23365
23366
23367 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23368 PyObject *obj;
23369 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23370 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23371 return SWIG_Py_Void();
23372 }
23373
23374 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23375 return SWIG_Python_InitShadowInstance(args);
23376 }
23377
23378 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23379 PyObject *resultobj = 0;
23380 int arg1 = (int) 0 ;
23381 wxPaintEvent *result = 0 ;
23382 int val1 ;
23383 int ecode1 = 0 ;
23384 PyObject * obj0 = 0 ;
23385 char * kwnames[] = {
23386 (char *) "Id", NULL
23387 };
23388
23389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23390 if (obj0) {
23391 ecode1 = SWIG_AsVal_int(obj0, &val1);
23392 if (!SWIG_IsOK(ecode1)) {
23393 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23394 }
23395 arg1 = static_cast< int >(val1);
23396 }
23397 {
23398 PyThreadState* __tstate = wxPyBeginAllowThreads();
23399 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23400 wxPyEndAllowThreads(__tstate);
23401 if (PyErr_Occurred()) SWIG_fail;
23402 }
23403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23404 return resultobj;
23405 fail:
23406 return NULL;
23407 }
23408
23409
23410 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23411 PyObject *obj;
23412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23413 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23414 return SWIG_Py_Void();
23415 }
23416
23417 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23418 return SWIG_Python_InitShadowInstance(args);
23419 }
23420
23421 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23422 PyObject *resultobj = 0;
23423 int arg1 = (int) 0 ;
23424 wxNcPaintEvent *result = 0 ;
23425 int val1 ;
23426 int ecode1 = 0 ;
23427 PyObject * obj0 = 0 ;
23428 char * kwnames[] = {
23429 (char *) "winid", NULL
23430 };
23431
23432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23433 if (obj0) {
23434 ecode1 = SWIG_AsVal_int(obj0, &val1);
23435 if (!SWIG_IsOK(ecode1)) {
23436 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23437 }
23438 arg1 = static_cast< int >(val1);
23439 }
23440 {
23441 PyThreadState* __tstate = wxPyBeginAllowThreads();
23442 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23443 wxPyEndAllowThreads(__tstate);
23444 if (PyErr_Occurred()) SWIG_fail;
23445 }
23446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23447 return resultobj;
23448 fail:
23449 return NULL;
23450 }
23451
23452
23453 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23454 PyObject *obj;
23455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23456 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23457 return SWIG_Py_Void();
23458 }
23459
23460 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23461 return SWIG_Python_InitShadowInstance(args);
23462 }
23463
23464 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23465 PyObject *resultobj = 0;
23466 int arg1 = (int) 0 ;
23467 wxDC *arg2 = (wxDC *) NULL ;
23468 wxEraseEvent *result = 0 ;
23469 int val1 ;
23470 int ecode1 = 0 ;
23471 void *argp2 = 0 ;
23472 int res2 = 0 ;
23473 PyObject * obj0 = 0 ;
23474 PyObject * obj1 = 0 ;
23475 char * kwnames[] = {
23476 (char *) "Id",(char *) "dc", NULL
23477 };
23478
23479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23480 if (obj0) {
23481 ecode1 = SWIG_AsVal_int(obj0, &val1);
23482 if (!SWIG_IsOK(ecode1)) {
23483 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23484 }
23485 arg1 = static_cast< int >(val1);
23486 }
23487 if (obj1) {
23488 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23489 if (!SWIG_IsOK(res2)) {
23490 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23491 }
23492 arg2 = reinterpret_cast< wxDC * >(argp2);
23493 }
23494 {
23495 PyThreadState* __tstate = wxPyBeginAllowThreads();
23496 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23497 wxPyEndAllowThreads(__tstate);
23498 if (PyErr_Occurred()) SWIG_fail;
23499 }
23500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23501 return resultobj;
23502 fail:
23503 return NULL;
23504 }
23505
23506
23507 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23508 PyObject *resultobj = 0;
23509 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23510 wxDC *result = 0 ;
23511 void *argp1 = 0 ;
23512 int res1 = 0 ;
23513 PyObject *swig_obj[1] ;
23514
23515 if (!args) SWIG_fail;
23516 swig_obj[0] = args;
23517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23518 if (!SWIG_IsOK(res1)) {
23519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23520 }
23521 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23522 {
23523 PyThreadState* __tstate = wxPyBeginAllowThreads();
23524 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23525 wxPyEndAllowThreads(__tstate);
23526 if (PyErr_Occurred()) SWIG_fail;
23527 }
23528 {
23529 resultobj = wxPyMake_wxObject(result, (bool)0);
23530 }
23531 return resultobj;
23532 fail:
23533 return NULL;
23534 }
23535
23536
23537 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23538 PyObject *obj;
23539 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23540 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23541 return SWIG_Py_Void();
23542 }
23543
23544 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23545 return SWIG_Python_InitShadowInstance(args);
23546 }
23547
23548 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23549 PyObject *resultobj = 0;
23550 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23551 int arg2 = (int) 0 ;
23552 wxFocusEvent *result = 0 ;
23553 int val1 ;
23554 int ecode1 = 0 ;
23555 int val2 ;
23556 int ecode2 = 0 ;
23557 PyObject * obj0 = 0 ;
23558 PyObject * obj1 = 0 ;
23559 char * kwnames[] = {
23560 (char *) "type",(char *) "winid", NULL
23561 };
23562
23563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23564 if (obj0) {
23565 ecode1 = SWIG_AsVal_int(obj0, &val1);
23566 if (!SWIG_IsOK(ecode1)) {
23567 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23568 }
23569 arg1 = static_cast< wxEventType >(val1);
23570 }
23571 if (obj1) {
23572 ecode2 = SWIG_AsVal_int(obj1, &val2);
23573 if (!SWIG_IsOK(ecode2)) {
23574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23575 }
23576 arg2 = static_cast< int >(val2);
23577 }
23578 {
23579 PyThreadState* __tstate = wxPyBeginAllowThreads();
23580 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23581 wxPyEndAllowThreads(__tstate);
23582 if (PyErr_Occurred()) SWIG_fail;
23583 }
23584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23592 PyObject *resultobj = 0;
23593 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23594 wxWindow *result = 0 ;
23595 void *argp1 = 0 ;
23596 int res1 = 0 ;
23597 PyObject *swig_obj[1] ;
23598
23599 if (!args) SWIG_fail;
23600 swig_obj[0] = args;
23601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23602 if (!SWIG_IsOK(res1)) {
23603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23604 }
23605 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23606 {
23607 PyThreadState* __tstate = wxPyBeginAllowThreads();
23608 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 {
23613 resultobj = wxPyMake_wxObject(result, (bool)0);
23614 }
23615 return resultobj;
23616 fail:
23617 return NULL;
23618 }
23619
23620
23621 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23622 PyObject *resultobj = 0;
23623 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23624 wxWindow *arg2 = (wxWindow *) 0 ;
23625 void *argp1 = 0 ;
23626 int res1 = 0 ;
23627 void *argp2 = 0 ;
23628 int res2 = 0 ;
23629 PyObject * obj0 = 0 ;
23630 PyObject * obj1 = 0 ;
23631 char * kwnames[] = {
23632 (char *) "self",(char *) "win", NULL
23633 };
23634
23635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23637 if (!SWIG_IsOK(res1)) {
23638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23639 }
23640 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23641 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23642 if (!SWIG_IsOK(res2)) {
23643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23644 }
23645 arg2 = reinterpret_cast< wxWindow * >(argp2);
23646 {
23647 PyThreadState* __tstate = wxPyBeginAllowThreads();
23648 (arg1)->SetWindow(arg2);
23649 wxPyEndAllowThreads(__tstate);
23650 if (PyErr_Occurred()) SWIG_fail;
23651 }
23652 resultobj = SWIG_Py_Void();
23653 return resultobj;
23654 fail:
23655 return NULL;
23656 }
23657
23658
23659 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23660 PyObject *obj;
23661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23662 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23663 return SWIG_Py_Void();
23664 }
23665
23666 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23667 return SWIG_Python_InitShadowInstance(args);
23668 }
23669
23670 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23671 PyObject *resultobj = 0;
23672 wxWindow *arg1 = (wxWindow *) NULL ;
23673 wxChildFocusEvent *result = 0 ;
23674 void *argp1 = 0 ;
23675 int res1 = 0 ;
23676 PyObject * obj0 = 0 ;
23677 char * kwnames[] = {
23678 (char *) "win", NULL
23679 };
23680
23681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23682 if (obj0) {
23683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23684 if (!SWIG_IsOK(res1)) {
23685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23686 }
23687 arg1 = reinterpret_cast< wxWindow * >(argp1);
23688 }
23689 {
23690 PyThreadState* __tstate = wxPyBeginAllowThreads();
23691 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23692 wxPyEndAllowThreads(__tstate);
23693 if (PyErr_Occurred()) SWIG_fail;
23694 }
23695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23696 return resultobj;
23697 fail:
23698 return NULL;
23699 }
23700
23701
23702 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23703 PyObject *resultobj = 0;
23704 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23705 wxWindow *result = 0 ;
23706 void *argp1 = 0 ;
23707 int res1 = 0 ;
23708 PyObject *swig_obj[1] ;
23709
23710 if (!args) SWIG_fail;
23711 swig_obj[0] = args;
23712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23713 if (!SWIG_IsOK(res1)) {
23714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23715 }
23716 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23717 {
23718 PyThreadState* __tstate = wxPyBeginAllowThreads();
23719 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23720 wxPyEndAllowThreads(__tstate);
23721 if (PyErr_Occurred()) SWIG_fail;
23722 }
23723 {
23724 resultobj = wxPyMake_wxObject(result, (bool)0);
23725 }
23726 return resultobj;
23727 fail:
23728 return NULL;
23729 }
23730
23731
23732 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23733 PyObject *obj;
23734 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23735 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23736 return SWIG_Py_Void();
23737 }
23738
23739 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23740 return SWIG_Python_InitShadowInstance(args);
23741 }
23742
23743 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23744 PyObject *resultobj = 0;
23745 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23746 bool arg2 = (bool) true ;
23747 int arg3 = (int) 0 ;
23748 wxActivateEvent *result = 0 ;
23749 int val1 ;
23750 int ecode1 = 0 ;
23751 bool val2 ;
23752 int ecode2 = 0 ;
23753 int val3 ;
23754 int ecode3 = 0 ;
23755 PyObject * obj0 = 0 ;
23756 PyObject * obj1 = 0 ;
23757 PyObject * obj2 = 0 ;
23758 char * kwnames[] = {
23759 (char *) "type",(char *) "active",(char *) "Id", NULL
23760 };
23761
23762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23763 if (obj0) {
23764 ecode1 = SWIG_AsVal_int(obj0, &val1);
23765 if (!SWIG_IsOK(ecode1)) {
23766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23767 }
23768 arg1 = static_cast< wxEventType >(val1);
23769 }
23770 if (obj1) {
23771 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23772 if (!SWIG_IsOK(ecode2)) {
23773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23774 }
23775 arg2 = static_cast< bool >(val2);
23776 }
23777 if (obj2) {
23778 ecode3 = SWIG_AsVal_int(obj2, &val3);
23779 if (!SWIG_IsOK(ecode3)) {
23780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23781 }
23782 arg3 = static_cast< int >(val3);
23783 }
23784 {
23785 PyThreadState* __tstate = wxPyBeginAllowThreads();
23786 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23787 wxPyEndAllowThreads(__tstate);
23788 if (PyErr_Occurred()) SWIG_fail;
23789 }
23790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23791 return resultobj;
23792 fail:
23793 return NULL;
23794 }
23795
23796
23797 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23798 PyObject *resultobj = 0;
23799 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23800 bool result;
23801 void *argp1 = 0 ;
23802 int res1 = 0 ;
23803 PyObject *swig_obj[1] ;
23804
23805 if (!args) SWIG_fail;
23806 swig_obj[0] = args;
23807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23808 if (!SWIG_IsOK(res1)) {
23809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23810 }
23811 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23812 {
23813 PyThreadState* __tstate = wxPyBeginAllowThreads();
23814 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23815 wxPyEndAllowThreads(__tstate);
23816 if (PyErr_Occurred()) SWIG_fail;
23817 }
23818 {
23819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23820 }
23821 return resultobj;
23822 fail:
23823 return NULL;
23824 }
23825
23826
23827 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23828 PyObject *obj;
23829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23830 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23831 return SWIG_Py_Void();
23832 }
23833
23834 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23835 return SWIG_Python_InitShadowInstance(args);
23836 }
23837
23838 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23839 PyObject *resultobj = 0;
23840 int arg1 = (int) 0 ;
23841 wxInitDialogEvent *result = 0 ;
23842 int val1 ;
23843 int ecode1 = 0 ;
23844 PyObject * obj0 = 0 ;
23845 char * kwnames[] = {
23846 (char *) "Id", NULL
23847 };
23848
23849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23850 if (obj0) {
23851 ecode1 = SWIG_AsVal_int(obj0, &val1);
23852 if (!SWIG_IsOK(ecode1)) {
23853 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23854 }
23855 arg1 = static_cast< int >(val1);
23856 }
23857 {
23858 PyThreadState* __tstate = wxPyBeginAllowThreads();
23859 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23860 wxPyEndAllowThreads(__tstate);
23861 if (PyErr_Occurred()) SWIG_fail;
23862 }
23863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23864 return resultobj;
23865 fail:
23866 return NULL;
23867 }
23868
23869
23870 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23871 PyObject *obj;
23872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23873 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23874 return SWIG_Py_Void();
23875 }
23876
23877 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23878 return SWIG_Python_InitShadowInstance(args);
23879 }
23880
23881 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23882 PyObject *resultobj = 0;
23883 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23884 int arg2 = (int) 0 ;
23885 wxMenu *arg3 = (wxMenu *) NULL ;
23886 wxMenuEvent *result = 0 ;
23887 int val1 ;
23888 int ecode1 = 0 ;
23889 int val2 ;
23890 int ecode2 = 0 ;
23891 void *argp3 = 0 ;
23892 int res3 = 0 ;
23893 PyObject * obj0 = 0 ;
23894 PyObject * obj1 = 0 ;
23895 PyObject * obj2 = 0 ;
23896 char * kwnames[] = {
23897 (char *) "type",(char *) "winid",(char *) "menu", NULL
23898 };
23899
23900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23901 if (obj0) {
23902 ecode1 = SWIG_AsVal_int(obj0, &val1);
23903 if (!SWIG_IsOK(ecode1)) {
23904 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23905 }
23906 arg1 = static_cast< wxEventType >(val1);
23907 }
23908 if (obj1) {
23909 ecode2 = SWIG_AsVal_int(obj1, &val2);
23910 if (!SWIG_IsOK(ecode2)) {
23911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23912 }
23913 arg2 = static_cast< int >(val2);
23914 }
23915 if (obj2) {
23916 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23917 if (!SWIG_IsOK(res3)) {
23918 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23919 }
23920 arg3 = reinterpret_cast< wxMenu * >(argp3);
23921 }
23922 {
23923 PyThreadState* __tstate = wxPyBeginAllowThreads();
23924 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23925 wxPyEndAllowThreads(__tstate);
23926 if (PyErr_Occurred()) SWIG_fail;
23927 }
23928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23929 return resultobj;
23930 fail:
23931 return NULL;
23932 }
23933
23934
23935 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23936 PyObject *resultobj = 0;
23937 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23938 int result;
23939 void *argp1 = 0 ;
23940 int res1 = 0 ;
23941 PyObject *swig_obj[1] ;
23942
23943 if (!args) SWIG_fail;
23944 swig_obj[0] = args;
23945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23946 if (!SWIG_IsOK(res1)) {
23947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23948 }
23949 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23950 {
23951 PyThreadState* __tstate = wxPyBeginAllowThreads();
23952 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23953 wxPyEndAllowThreads(__tstate);
23954 if (PyErr_Occurred()) SWIG_fail;
23955 }
23956 resultobj = SWIG_From_int(static_cast< int >(result));
23957 return resultobj;
23958 fail:
23959 return NULL;
23960 }
23961
23962
23963 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23964 PyObject *resultobj = 0;
23965 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23966 bool result;
23967 void *argp1 = 0 ;
23968 int res1 = 0 ;
23969 PyObject *swig_obj[1] ;
23970
23971 if (!args) SWIG_fail;
23972 swig_obj[0] = args;
23973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23974 if (!SWIG_IsOK(res1)) {
23975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23976 }
23977 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23978 {
23979 PyThreadState* __tstate = wxPyBeginAllowThreads();
23980 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23981 wxPyEndAllowThreads(__tstate);
23982 if (PyErr_Occurred()) SWIG_fail;
23983 }
23984 {
23985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23986 }
23987 return resultobj;
23988 fail:
23989 return NULL;
23990 }
23991
23992
23993 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23994 PyObject *resultobj = 0;
23995 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23996 wxMenu *result = 0 ;
23997 void *argp1 = 0 ;
23998 int res1 = 0 ;
23999 PyObject *swig_obj[1] ;
24000
24001 if (!args) SWIG_fail;
24002 swig_obj[0] = args;
24003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24004 if (!SWIG_IsOK(res1)) {
24005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24006 }
24007 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24008 {
24009 PyThreadState* __tstate = wxPyBeginAllowThreads();
24010 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24011 wxPyEndAllowThreads(__tstate);
24012 if (PyErr_Occurred()) SWIG_fail;
24013 }
24014 {
24015 resultobj = wxPyMake_wxObject(result, (bool)0);
24016 }
24017 return resultobj;
24018 fail:
24019 return NULL;
24020 }
24021
24022
24023 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24024 PyObject *obj;
24025 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24026 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24027 return SWIG_Py_Void();
24028 }
24029
24030 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24031 return SWIG_Python_InitShadowInstance(args);
24032 }
24033
24034 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24035 PyObject *resultobj = 0;
24036 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24037 int arg2 = (int) 0 ;
24038 wxCloseEvent *result = 0 ;
24039 int val1 ;
24040 int ecode1 = 0 ;
24041 int val2 ;
24042 int ecode2 = 0 ;
24043 PyObject * obj0 = 0 ;
24044 PyObject * obj1 = 0 ;
24045 char * kwnames[] = {
24046 (char *) "type",(char *) "winid", NULL
24047 };
24048
24049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24050 if (obj0) {
24051 ecode1 = SWIG_AsVal_int(obj0, &val1);
24052 if (!SWIG_IsOK(ecode1)) {
24053 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24054 }
24055 arg1 = static_cast< wxEventType >(val1);
24056 }
24057 if (obj1) {
24058 ecode2 = SWIG_AsVal_int(obj1, &val2);
24059 if (!SWIG_IsOK(ecode2)) {
24060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24061 }
24062 arg2 = static_cast< int >(val2);
24063 }
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24067 wxPyEndAllowThreads(__tstate);
24068 if (PyErr_Occurred()) SWIG_fail;
24069 }
24070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24071 return resultobj;
24072 fail:
24073 return NULL;
24074 }
24075
24076
24077 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24078 PyObject *resultobj = 0;
24079 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24080 bool arg2 ;
24081 void *argp1 = 0 ;
24082 int res1 = 0 ;
24083 bool val2 ;
24084 int ecode2 = 0 ;
24085 PyObject * obj0 = 0 ;
24086 PyObject * obj1 = 0 ;
24087 char * kwnames[] = {
24088 (char *) "self",(char *) "logOff", NULL
24089 };
24090
24091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24093 if (!SWIG_IsOK(res1)) {
24094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24095 }
24096 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24097 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24098 if (!SWIG_IsOK(ecode2)) {
24099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24100 }
24101 arg2 = static_cast< bool >(val2);
24102 {
24103 PyThreadState* __tstate = wxPyBeginAllowThreads();
24104 (arg1)->SetLoggingOff(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_GetLoggingOff(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_GetLoggingOff" "', 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)->GetLoggingOff();
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_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24146 PyObject *resultobj = 0;
24147 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24148 bool arg2 = (bool) true ;
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 *) "veto", NULL
24157 };
24158
24159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",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_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24163 }
24164 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24165 if (obj1) {
24166 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24167 if (!SWIG_IsOK(ecode2)) {
24168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24169 }
24170 arg2 = static_cast< bool >(val2);
24171 }
24172 {
24173 PyThreadState* __tstate = wxPyBeginAllowThreads();
24174 (arg1)->Veto(arg2);
24175 wxPyEndAllowThreads(__tstate);
24176 if (PyErr_Occurred()) SWIG_fail;
24177 }
24178 resultobj = SWIG_Py_Void();
24179 return resultobj;
24180 fail:
24181 return NULL;
24182 }
24183
24184
24185 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24186 PyObject *resultobj = 0;
24187 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24188 bool result;
24189 void *argp1 = 0 ;
24190 int res1 = 0 ;
24191 PyObject *swig_obj[1] ;
24192
24193 if (!args) SWIG_fail;
24194 swig_obj[0] = args;
24195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24196 if (!SWIG_IsOK(res1)) {
24197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24198 }
24199 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24200 {
24201 PyThreadState* __tstate = wxPyBeginAllowThreads();
24202 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24203 wxPyEndAllowThreads(__tstate);
24204 if (PyErr_Occurred()) SWIG_fail;
24205 }
24206 {
24207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24208 }
24209 return resultobj;
24210 fail:
24211 return NULL;
24212 }
24213
24214
24215 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24216 PyObject *resultobj = 0;
24217 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24218 bool arg2 ;
24219 void *argp1 = 0 ;
24220 int res1 = 0 ;
24221 bool val2 ;
24222 int ecode2 = 0 ;
24223 PyObject * obj0 = 0 ;
24224 PyObject * obj1 = 0 ;
24225 char * kwnames[] = {
24226 (char *) "self",(char *) "canVeto", NULL
24227 };
24228
24229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24231 if (!SWIG_IsOK(res1)) {
24232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24233 }
24234 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24235 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24236 if (!SWIG_IsOK(ecode2)) {
24237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24238 }
24239 arg2 = static_cast< bool >(val2);
24240 {
24241 PyThreadState* __tstate = wxPyBeginAllowThreads();
24242 (arg1)->SetCanVeto(arg2);
24243 wxPyEndAllowThreads(__tstate);
24244 if (PyErr_Occurred()) SWIG_fail;
24245 }
24246 resultobj = SWIG_Py_Void();
24247 return resultobj;
24248 fail:
24249 return NULL;
24250 }
24251
24252
24253 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24254 PyObject *resultobj = 0;
24255 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24256 bool result;
24257 void *argp1 = 0 ;
24258 int res1 = 0 ;
24259 PyObject *swig_obj[1] ;
24260
24261 if (!args) SWIG_fail;
24262 swig_obj[0] = args;
24263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24264 if (!SWIG_IsOK(res1)) {
24265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24266 }
24267 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24268 {
24269 PyThreadState* __tstate = wxPyBeginAllowThreads();
24270 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24271 wxPyEndAllowThreads(__tstate);
24272 if (PyErr_Occurred()) SWIG_fail;
24273 }
24274 {
24275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24276 }
24277 return resultobj;
24278 fail:
24279 return NULL;
24280 }
24281
24282
24283 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24284 PyObject *obj;
24285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24286 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24287 return SWIG_Py_Void();
24288 }
24289
24290 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24291 return SWIG_Python_InitShadowInstance(args);
24292 }
24293
24294 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24295 PyObject *resultobj = 0;
24296 int arg1 = (int) 0 ;
24297 bool arg2 = (bool) false ;
24298 wxShowEvent *result = 0 ;
24299 int val1 ;
24300 int ecode1 = 0 ;
24301 bool val2 ;
24302 int ecode2 = 0 ;
24303 PyObject * obj0 = 0 ;
24304 PyObject * obj1 = 0 ;
24305 char * kwnames[] = {
24306 (char *) "winid",(char *) "show", NULL
24307 };
24308
24309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24310 if (obj0) {
24311 ecode1 = SWIG_AsVal_int(obj0, &val1);
24312 if (!SWIG_IsOK(ecode1)) {
24313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24314 }
24315 arg1 = static_cast< int >(val1);
24316 }
24317 if (obj1) {
24318 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24319 if (!SWIG_IsOK(ecode2)) {
24320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24321 }
24322 arg2 = static_cast< bool >(val2);
24323 }
24324 {
24325 PyThreadState* __tstate = wxPyBeginAllowThreads();
24326 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24327 wxPyEndAllowThreads(__tstate);
24328 if (PyErr_Occurred()) SWIG_fail;
24329 }
24330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24331 return resultobj;
24332 fail:
24333 return NULL;
24334 }
24335
24336
24337 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24338 PyObject *resultobj = 0;
24339 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24340 bool arg2 ;
24341 void *argp1 = 0 ;
24342 int res1 = 0 ;
24343 bool val2 ;
24344 int ecode2 = 0 ;
24345 PyObject * obj0 = 0 ;
24346 PyObject * obj1 = 0 ;
24347 char * kwnames[] = {
24348 (char *) "self",(char *) "show", NULL
24349 };
24350
24351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24353 if (!SWIG_IsOK(res1)) {
24354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24355 }
24356 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24357 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24358 if (!SWIG_IsOK(ecode2)) {
24359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24360 }
24361 arg2 = static_cast< bool >(val2);
24362 {
24363 PyThreadState* __tstate = wxPyBeginAllowThreads();
24364 (arg1)->SetShow(arg2);
24365 wxPyEndAllowThreads(__tstate);
24366 if (PyErr_Occurred()) SWIG_fail;
24367 }
24368 resultobj = SWIG_Py_Void();
24369 return resultobj;
24370 fail:
24371 return NULL;
24372 }
24373
24374
24375 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24376 PyObject *resultobj = 0;
24377 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24378 bool result;
24379 void *argp1 = 0 ;
24380 int res1 = 0 ;
24381 PyObject *swig_obj[1] ;
24382
24383 if (!args) SWIG_fail;
24384 swig_obj[0] = args;
24385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24386 if (!SWIG_IsOK(res1)) {
24387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24388 }
24389 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24390 {
24391 PyThreadState* __tstate = wxPyBeginAllowThreads();
24392 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24393 wxPyEndAllowThreads(__tstate);
24394 if (PyErr_Occurred()) SWIG_fail;
24395 }
24396 {
24397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24398 }
24399 return resultobj;
24400 fail:
24401 return NULL;
24402 }
24403
24404
24405 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24406 PyObject *obj;
24407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24408 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24409 return SWIG_Py_Void();
24410 }
24411
24412 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24413 return SWIG_Python_InitShadowInstance(args);
24414 }
24415
24416 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24417 PyObject *resultobj = 0;
24418 int arg1 = (int) 0 ;
24419 bool arg2 = (bool) true ;
24420 wxIconizeEvent *result = 0 ;
24421 int val1 ;
24422 int ecode1 = 0 ;
24423 bool val2 ;
24424 int ecode2 = 0 ;
24425 PyObject * obj0 = 0 ;
24426 PyObject * obj1 = 0 ;
24427 char * kwnames[] = {
24428 (char *) "id",(char *) "iconized", NULL
24429 };
24430
24431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24432 if (obj0) {
24433 ecode1 = SWIG_AsVal_int(obj0, &val1);
24434 if (!SWIG_IsOK(ecode1)) {
24435 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24436 }
24437 arg1 = static_cast< int >(val1);
24438 }
24439 if (obj1) {
24440 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24441 if (!SWIG_IsOK(ecode2)) {
24442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24443 }
24444 arg2 = static_cast< bool >(val2);
24445 }
24446 {
24447 PyThreadState* __tstate = wxPyBeginAllowThreads();
24448 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24449 wxPyEndAllowThreads(__tstate);
24450 if (PyErr_Occurred()) SWIG_fail;
24451 }
24452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24453 return resultobj;
24454 fail:
24455 return NULL;
24456 }
24457
24458
24459 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24460 PyObject *resultobj = 0;
24461 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24462 bool result;
24463 void *argp1 = 0 ;
24464 int res1 = 0 ;
24465 PyObject *swig_obj[1] ;
24466
24467 if (!args) SWIG_fail;
24468 swig_obj[0] = args;
24469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24470 if (!SWIG_IsOK(res1)) {
24471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24472 }
24473 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24474 {
24475 PyThreadState* __tstate = wxPyBeginAllowThreads();
24476 result = (bool)(arg1)->Iconized();
24477 wxPyEndAllowThreads(__tstate);
24478 if (PyErr_Occurred()) SWIG_fail;
24479 }
24480 {
24481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24482 }
24483 return resultobj;
24484 fail:
24485 return NULL;
24486 }
24487
24488
24489 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24490 PyObject *obj;
24491 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24492 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24493 return SWIG_Py_Void();
24494 }
24495
24496 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24497 return SWIG_Python_InitShadowInstance(args);
24498 }
24499
24500 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24501 PyObject *resultobj = 0;
24502 int arg1 = (int) 0 ;
24503 wxMaximizeEvent *result = 0 ;
24504 int val1 ;
24505 int ecode1 = 0 ;
24506 PyObject * obj0 = 0 ;
24507 char * kwnames[] = {
24508 (char *) "id", NULL
24509 };
24510
24511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24512 if (obj0) {
24513 ecode1 = SWIG_AsVal_int(obj0, &val1);
24514 if (!SWIG_IsOK(ecode1)) {
24515 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24516 }
24517 arg1 = static_cast< int >(val1);
24518 }
24519 {
24520 PyThreadState* __tstate = wxPyBeginAllowThreads();
24521 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24522 wxPyEndAllowThreads(__tstate);
24523 if (PyErr_Occurred()) SWIG_fail;
24524 }
24525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24526 return resultobj;
24527 fail:
24528 return NULL;
24529 }
24530
24531
24532 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24533 PyObject *obj;
24534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24535 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24536 return SWIG_Py_Void();
24537 }
24538
24539 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24540 return SWIG_Python_InitShadowInstance(args);
24541 }
24542
24543 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24544 PyObject *resultobj = 0;
24545 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24546 wxPoint result;
24547 void *argp1 = 0 ;
24548 int res1 = 0 ;
24549 PyObject *swig_obj[1] ;
24550
24551 if (!args) SWIG_fail;
24552 swig_obj[0] = args;
24553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24554 if (!SWIG_IsOK(res1)) {
24555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24556 }
24557 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24558 {
24559 PyThreadState* __tstate = wxPyBeginAllowThreads();
24560 result = (arg1)->GetPosition();
24561 wxPyEndAllowThreads(__tstate);
24562 if (PyErr_Occurred()) SWIG_fail;
24563 }
24564 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24565 return resultobj;
24566 fail:
24567 return NULL;
24568 }
24569
24570
24571 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24572 PyObject *resultobj = 0;
24573 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24574 int result;
24575 void *argp1 = 0 ;
24576 int res1 = 0 ;
24577 PyObject *swig_obj[1] ;
24578
24579 if (!args) SWIG_fail;
24580 swig_obj[0] = args;
24581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24582 if (!SWIG_IsOK(res1)) {
24583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24584 }
24585 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24586 {
24587 PyThreadState* __tstate = wxPyBeginAllowThreads();
24588 result = (int)(arg1)->GetNumberOfFiles();
24589 wxPyEndAllowThreads(__tstate);
24590 if (PyErr_Occurred()) SWIG_fail;
24591 }
24592 resultobj = SWIG_From_int(static_cast< int >(result));
24593 return resultobj;
24594 fail:
24595 return NULL;
24596 }
24597
24598
24599 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24600 PyObject *resultobj = 0;
24601 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24602 PyObject *result = 0 ;
24603 void *argp1 = 0 ;
24604 int res1 = 0 ;
24605 PyObject *swig_obj[1] ;
24606
24607 if (!args) SWIG_fail;
24608 swig_obj[0] = args;
24609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24610 if (!SWIG_IsOK(res1)) {
24611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24612 }
24613 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24614 {
24615 PyThreadState* __tstate = wxPyBeginAllowThreads();
24616 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24617 wxPyEndAllowThreads(__tstate);
24618 if (PyErr_Occurred()) SWIG_fail;
24619 }
24620 resultobj = result;
24621 return resultobj;
24622 fail:
24623 return NULL;
24624 }
24625
24626
24627 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24628 PyObject *obj;
24629 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24630 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24631 return SWIG_Py_Void();
24632 }
24633
24634 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24635 PyObject *resultobj = 0;
24636 int arg1 = (int) 0 ;
24637 wxUpdateUIEvent *result = 0 ;
24638 int val1 ;
24639 int ecode1 = 0 ;
24640 PyObject * obj0 = 0 ;
24641 char * kwnames[] = {
24642 (char *) "commandId", NULL
24643 };
24644
24645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24646 if (obj0) {
24647 ecode1 = SWIG_AsVal_int(obj0, &val1);
24648 if (!SWIG_IsOK(ecode1)) {
24649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24650 }
24651 arg1 = static_cast< int >(val1);
24652 }
24653 {
24654 PyThreadState* __tstate = wxPyBeginAllowThreads();
24655 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24656 wxPyEndAllowThreads(__tstate);
24657 if (PyErr_Occurred()) SWIG_fail;
24658 }
24659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24660 return resultobj;
24661 fail:
24662 return NULL;
24663 }
24664
24665
24666 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24667 PyObject *resultobj = 0;
24668 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24669 bool result;
24670 void *argp1 = 0 ;
24671 int res1 = 0 ;
24672 PyObject *swig_obj[1] ;
24673
24674 if (!args) SWIG_fail;
24675 swig_obj[0] = args;
24676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24677 if (!SWIG_IsOK(res1)) {
24678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24679 }
24680 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24681 {
24682 PyThreadState* __tstate = wxPyBeginAllowThreads();
24683 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24684 wxPyEndAllowThreads(__tstate);
24685 if (PyErr_Occurred()) SWIG_fail;
24686 }
24687 {
24688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24689 }
24690 return resultobj;
24691 fail:
24692 return NULL;
24693 }
24694
24695
24696 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24697 PyObject *resultobj = 0;
24698 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24699 bool result;
24700 void *argp1 = 0 ;
24701 int res1 = 0 ;
24702 PyObject *swig_obj[1] ;
24703
24704 if (!args) SWIG_fail;
24705 swig_obj[0] = args;
24706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24707 if (!SWIG_IsOK(res1)) {
24708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24709 }
24710 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24711 {
24712 PyThreadState* __tstate = wxPyBeginAllowThreads();
24713 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24714 wxPyEndAllowThreads(__tstate);
24715 if (PyErr_Occurred()) SWIG_fail;
24716 }
24717 {
24718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24719 }
24720 return resultobj;
24721 fail:
24722 return NULL;
24723 }
24724
24725
24726 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24727 PyObject *resultobj = 0;
24728 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24729 bool result;
24730 void *argp1 = 0 ;
24731 int res1 = 0 ;
24732 PyObject *swig_obj[1] ;
24733
24734 if (!args) SWIG_fail;
24735 swig_obj[0] = args;
24736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24737 if (!SWIG_IsOK(res1)) {
24738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24739 }
24740 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24741 {
24742 PyThreadState* __tstate = wxPyBeginAllowThreads();
24743 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24744 wxPyEndAllowThreads(__tstate);
24745 if (PyErr_Occurred()) SWIG_fail;
24746 }
24747 {
24748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24749 }
24750 return resultobj;
24751 fail:
24752 return NULL;
24753 }
24754
24755
24756 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24757 PyObject *resultobj = 0;
24758 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24759 wxString result;
24760 void *argp1 = 0 ;
24761 int res1 = 0 ;
24762 PyObject *swig_obj[1] ;
24763
24764 if (!args) SWIG_fail;
24765 swig_obj[0] = args;
24766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24767 if (!SWIG_IsOK(res1)) {
24768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24769 }
24770 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24771 {
24772 PyThreadState* __tstate = wxPyBeginAllowThreads();
24773 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24774 wxPyEndAllowThreads(__tstate);
24775 if (PyErr_Occurred()) SWIG_fail;
24776 }
24777 {
24778 #if wxUSE_UNICODE
24779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24780 #else
24781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24782 #endif
24783 }
24784 return resultobj;
24785 fail:
24786 return NULL;
24787 }
24788
24789
24790 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24791 PyObject *resultobj = 0;
24792 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24793 bool result;
24794 void *argp1 = 0 ;
24795 int res1 = 0 ;
24796 PyObject *swig_obj[1] ;
24797
24798 if (!args) SWIG_fail;
24799 swig_obj[0] = args;
24800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24801 if (!SWIG_IsOK(res1)) {
24802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24803 }
24804 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24805 {
24806 PyThreadState* __tstate = wxPyBeginAllowThreads();
24807 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24808 wxPyEndAllowThreads(__tstate);
24809 if (PyErr_Occurred()) SWIG_fail;
24810 }
24811 {
24812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24813 }
24814 return resultobj;
24815 fail:
24816 return NULL;
24817 }
24818
24819
24820 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24821 PyObject *resultobj = 0;
24822 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24823 bool result;
24824 void *argp1 = 0 ;
24825 int res1 = 0 ;
24826 PyObject *swig_obj[1] ;
24827
24828 if (!args) SWIG_fail;
24829 swig_obj[0] = args;
24830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24831 if (!SWIG_IsOK(res1)) {
24832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24833 }
24834 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24835 {
24836 PyThreadState* __tstate = wxPyBeginAllowThreads();
24837 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24838 wxPyEndAllowThreads(__tstate);
24839 if (PyErr_Occurred()) SWIG_fail;
24840 }
24841 {
24842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24843 }
24844 return resultobj;
24845 fail:
24846 return NULL;
24847 }
24848
24849
24850 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24851 PyObject *resultobj = 0;
24852 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24853 bool result;
24854 void *argp1 = 0 ;
24855 int res1 = 0 ;
24856 PyObject *swig_obj[1] ;
24857
24858 if (!args) SWIG_fail;
24859 swig_obj[0] = args;
24860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24861 if (!SWIG_IsOK(res1)) {
24862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24863 }
24864 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24865 {
24866 PyThreadState* __tstate = wxPyBeginAllowThreads();
24867 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24868 wxPyEndAllowThreads(__tstate);
24869 if (PyErr_Occurred()) SWIG_fail;
24870 }
24871 {
24872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24873 }
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24881 PyObject *resultobj = 0;
24882 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24883 bool result;
24884 void *argp1 = 0 ;
24885 int res1 = 0 ;
24886 PyObject *swig_obj[1] ;
24887
24888 if (!args) SWIG_fail;
24889 swig_obj[0] = args;
24890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24891 if (!SWIG_IsOK(res1)) {
24892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24893 }
24894 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24895 {
24896 PyThreadState* __tstate = wxPyBeginAllowThreads();
24897 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24898 wxPyEndAllowThreads(__tstate);
24899 if (PyErr_Occurred()) SWIG_fail;
24900 }
24901 {
24902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24903 }
24904 return resultobj;
24905 fail:
24906 return NULL;
24907 }
24908
24909
24910 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24911 PyObject *resultobj = 0;
24912 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24913 bool arg2 ;
24914 void *argp1 = 0 ;
24915 int res1 = 0 ;
24916 bool val2 ;
24917 int ecode2 = 0 ;
24918 PyObject * obj0 = 0 ;
24919 PyObject * obj1 = 0 ;
24920 char * kwnames[] = {
24921 (char *) "self",(char *) "check", NULL
24922 };
24923
24924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24926 if (!SWIG_IsOK(res1)) {
24927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24928 }
24929 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24930 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24931 if (!SWIG_IsOK(ecode2)) {
24932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24933 }
24934 arg2 = static_cast< bool >(val2);
24935 {
24936 PyThreadState* __tstate = wxPyBeginAllowThreads();
24937 (arg1)->Check(arg2);
24938 wxPyEndAllowThreads(__tstate);
24939 if (PyErr_Occurred()) SWIG_fail;
24940 }
24941 resultobj = SWIG_Py_Void();
24942 return resultobj;
24943 fail:
24944 return NULL;
24945 }
24946
24947
24948 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24949 PyObject *resultobj = 0;
24950 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24951 bool arg2 ;
24952 void *argp1 = 0 ;
24953 int res1 = 0 ;
24954 bool val2 ;
24955 int ecode2 = 0 ;
24956 PyObject * obj0 = 0 ;
24957 PyObject * obj1 = 0 ;
24958 char * kwnames[] = {
24959 (char *) "self",(char *) "enable", NULL
24960 };
24961
24962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24964 if (!SWIG_IsOK(res1)) {
24965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24966 }
24967 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24968 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24969 if (!SWIG_IsOK(ecode2)) {
24970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24971 }
24972 arg2 = static_cast< bool >(val2);
24973 {
24974 PyThreadState* __tstate = wxPyBeginAllowThreads();
24975 (arg1)->Enable(arg2);
24976 wxPyEndAllowThreads(__tstate);
24977 if (PyErr_Occurred()) SWIG_fail;
24978 }
24979 resultobj = SWIG_Py_Void();
24980 return resultobj;
24981 fail:
24982 return NULL;
24983 }
24984
24985
24986 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24987 PyObject *resultobj = 0;
24988 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24989 bool arg2 ;
24990 void *argp1 = 0 ;
24991 int res1 = 0 ;
24992 bool val2 ;
24993 int ecode2 = 0 ;
24994 PyObject * obj0 = 0 ;
24995 PyObject * obj1 = 0 ;
24996 char * kwnames[] = {
24997 (char *) "self",(char *) "show", NULL
24998 };
24999
25000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25002 if (!SWIG_IsOK(res1)) {
25003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25004 }
25005 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25006 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25007 if (!SWIG_IsOK(ecode2)) {
25008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25009 }
25010 arg2 = static_cast< bool >(val2);
25011 {
25012 PyThreadState* __tstate = wxPyBeginAllowThreads();
25013 (arg1)->Show(arg2);
25014 wxPyEndAllowThreads(__tstate);
25015 if (PyErr_Occurred()) SWIG_fail;
25016 }
25017 resultobj = SWIG_Py_Void();
25018 return resultobj;
25019 fail:
25020 return NULL;
25021 }
25022
25023
25024 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25025 PyObject *resultobj = 0;
25026 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25027 wxString *arg2 = 0 ;
25028 void *argp1 = 0 ;
25029 int res1 = 0 ;
25030 bool temp2 = false ;
25031 PyObject * obj0 = 0 ;
25032 PyObject * obj1 = 0 ;
25033 char * kwnames[] = {
25034 (char *) "self",(char *) "text", NULL
25035 };
25036
25037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25039 if (!SWIG_IsOK(res1)) {
25040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25041 }
25042 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25043 {
25044 arg2 = wxString_in_helper(obj1);
25045 if (arg2 == NULL) SWIG_fail;
25046 temp2 = true;
25047 }
25048 {
25049 PyThreadState* __tstate = wxPyBeginAllowThreads();
25050 (arg1)->SetText((wxString const &)*arg2);
25051 wxPyEndAllowThreads(__tstate);
25052 if (PyErr_Occurred()) SWIG_fail;
25053 }
25054 resultobj = SWIG_Py_Void();
25055 {
25056 if (temp2)
25057 delete arg2;
25058 }
25059 return resultobj;
25060 fail:
25061 {
25062 if (temp2)
25063 delete arg2;
25064 }
25065 return NULL;
25066 }
25067
25068
25069 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25070 PyObject *resultobj = 0;
25071 long arg1 ;
25072 long val1 ;
25073 int ecode1 = 0 ;
25074 PyObject * obj0 = 0 ;
25075 char * kwnames[] = {
25076 (char *) "updateInterval", NULL
25077 };
25078
25079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25080 ecode1 = SWIG_AsVal_long(obj0, &val1);
25081 if (!SWIG_IsOK(ecode1)) {
25082 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25083 }
25084 arg1 = static_cast< long >(val1);
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 wxUpdateUIEvent::SetUpdateInterval(arg1);
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 resultobj = SWIG_Py_Void();
25092 return resultobj;
25093 fail:
25094 return NULL;
25095 }
25096
25097
25098 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25099 PyObject *resultobj = 0;
25100 long result;
25101
25102 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25103 {
25104 PyThreadState* __tstate = wxPyBeginAllowThreads();
25105 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25106 wxPyEndAllowThreads(__tstate);
25107 if (PyErr_Occurred()) SWIG_fail;
25108 }
25109 resultobj = SWIG_From_long(static_cast< long >(result));
25110 return resultobj;
25111 fail:
25112 return NULL;
25113 }
25114
25115
25116 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25117 PyObject *resultobj = 0;
25118 wxWindow *arg1 = (wxWindow *) 0 ;
25119 bool result;
25120 void *argp1 = 0 ;
25121 int res1 = 0 ;
25122 PyObject * obj0 = 0 ;
25123 char * kwnames[] = {
25124 (char *) "win", NULL
25125 };
25126
25127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25129 if (!SWIG_IsOK(res1)) {
25130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25131 }
25132 arg1 = reinterpret_cast< wxWindow * >(argp1);
25133 {
25134 PyThreadState* __tstate = wxPyBeginAllowThreads();
25135 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25136 wxPyEndAllowThreads(__tstate);
25137 if (PyErr_Occurred()) SWIG_fail;
25138 }
25139 {
25140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25141 }
25142 return resultobj;
25143 fail:
25144 return NULL;
25145 }
25146
25147
25148 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25149 PyObject *resultobj = 0;
25150
25151 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25152 {
25153 PyThreadState* __tstate = wxPyBeginAllowThreads();
25154 wxUpdateUIEvent::ResetUpdateTime();
25155 wxPyEndAllowThreads(__tstate);
25156 if (PyErr_Occurred()) SWIG_fail;
25157 }
25158 resultobj = SWIG_Py_Void();
25159 return resultobj;
25160 fail:
25161 return NULL;
25162 }
25163
25164
25165 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25166 PyObject *resultobj = 0;
25167 wxUpdateUIMode arg1 ;
25168 int val1 ;
25169 int ecode1 = 0 ;
25170 PyObject * obj0 = 0 ;
25171 char * kwnames[] = {
25172 (char *) "mode", NULL
25173 };
25174
25175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25176 ecode1 = SWIG_AsVal_int(obj0, &val1);
25177 if (!SWIG_IsOK(ecode1)) {
25178 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25179 }
25180 arg1 = static_cast< wxUpdateUIMode >(val1);
25181 {
25182 PyThreadState* __tstate = wxPyBeginAllowThreads();
25183 wxUpdateUIEvent::SetMode(arg1);
25184 wxPyEndAllowThreads(__tstate);
25185 if (PyErr_Occurred()) SWIG_fail;
25186 }
25187 resultobj = SWIG_Py_Void();
25188 return resultobj;
25189 fail:
25190 return NULL;
25191 }
25192
25193
25194 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25195 PyObject *resultobj = 0;
25196 wxUpdateUIMode result;
25197
25198 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25199 {
25200 PyThreadState* __tstate = wxPyBeginAllowThreads();
25201 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25202 wxPyEndAllowThreads(__tstate);
25203 if (PyErr_Occurred()) SWIG_fail;
25204 }
25205 resultobj = SWIG_From_int(static_cast< int >(result));
25206 return resultobj;
25207 fail:
25208 return NULL;
25209 }
25210
25211
25212 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25213 PyObject *obj;
25214 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25215 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25216 return SWIG_Py_Void();
25217 }
25218
25219 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25220 return SWIG_Python_InitShadowInstance(args);
25221 }
25222
25223 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25224 PyObject *resultobj = 0;
25225 wxSysColourChangedEvent *result = 0 ;
25226
25227 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25228 {
25229 PyThreadState* __tstate = wxPyBeginAllowThreads();
25230 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25231 wxPyEndAllowThreads(__tstate);
25232 if (PyErr_Occurred()) SWIG_fail;
25233 }
25234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25235 return resultobj;
25236 fail:
25237 return NULL;
25238 }
25239
25240
25241 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25242 PyObject *obj;
25243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25244 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25245 return SWIG_Py_Void();
25246 }
25247
25248 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25249 return SWIG_Python_InitShadowInstance(args);
25250 }
25251
25252 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25253 PyObject *resultobj = 0;
25254 int arg1 = (int) 0 ;
25255 wxWindow *arg2 = (wxWindow *) NULL ;
25256 wxMouseCaptureChangedEvent *result = 0 ;
25257 int val1 ;
25258 int ecode1 = 0 ;
25259 void *argp2 = 0 ;
25260 int res2 = 0 ;
25261 PyObject * obj0 = 0 ;
25262 PyObject * obj1 = 0 ;
25263 char * kwnames[] = {
25264 (char *) "winid",(char *) "gainedCapture", NULL
25265 };
25266
25267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25268 if (obj0) {
25269 ecode1 = SWIG_AsVal_int(obj0, &val1);
25270 if (!SWIG_IsOK(ecode1)) {
25271 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25272 }
25273 arg1 = static_cast< int >(val1);
25274 }
25275 if (obj1) {
25276 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25277 if (!SWIG_IsOK(res2)) {
25278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25279 }
25280 arg2 = reinterpret_cast< wxWindow * >(argp2);
25281 }
25282 {
25283 PyThreadState* __tstate = wxPyBeginAllowThreads();
25284 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25285 wxPyEndAllowThreads(__tstate);
25286 if (PyErr_Occurred()) SWIG_fail;
25287 }
25288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25289 return resultobj;
25290 fail:
25291 return NULL;
25292 }
25293
25294
25295 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25296 PyObject *resultobj = 0;
25297 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25298 wxWindow *result = 0 ;
25299 void *argp1 = 0 ;
25300 int res1 = 0 ;
25301 PyObject *swig_obj[1] ;
25302
25303 if (!args) SWIG_fail;
25304 swig_obj[0] = args;
25305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25306 if (!SWIG_IsOK(res1)) {
25307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25308 }
25309 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25313 wxPyEndAllowThreads(__tstate);
25314 if (PyErr_Occurred()) SWIG_fail;
25315 }
25316 {
25317 resultobj = wxPyMake_wxObject(result, (bool)0);
25318 }
25319 return resultobj;
25320 fail:
25321 return NULL;
25322 }
25323
25324
25325 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25326 PyObject *obj;
25327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25328 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25329 return SWIG_Py_Void();
25330 }
25331
25332 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25333 return SWIG_Python_InitShadowInstance(args);
25334 }
25335
25336 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25337 PyObject *resultobj = 0;
25338 wxDisplayChangedEvent *result = 0 ;
25339
25340 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25341 {
25342 PyThreadState* __tstate = wxPyBeginAllowThreads();
25343 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25344 wxPyEndAllowThreads(__tstate);
25345 if (PyErr_Occurred()) SWIG_fail;
25346 }
25347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25348 return resultobj;
25349 fail:
25350 return NULL;
25351 }
25352
25353
25354 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25355 PyObject *obj;
25356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25357 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25358 return SWIG_Py_Void();
25359 }
25360
25361 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25362 return SWIG_Python_InitShadowInstance(args);
25363 }
25364
25365 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25366 PyObject *resultobj = 0;
25367 int arg1 = (int) 0 ;
25368 wxPaletteChangedEvent *result = 0 ;
25369 int val1 ;
25370 int ecode1 = 0 ;
25371 PyObject * obj0 = 0 ;
25372 char * kwnames[] = {
25373 (char *) "id", NULL
25374 };
25375
25376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25377 if (obj0) {
25378 ecode1 = SWIG_AsVal_int(obj0, &val1);
25379 if (!SWIG_IsOK(ecode1)) {
25380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25381 }
25382 arg1 = static_cast< int >(val1);
25383 }
25384 {
25385 PyThreadState* __tstate = wxPyBeginAllowThreads();
25386 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25387 wxPyEndAllowThreads(__tstate);
25388 if (PyErr_Occurred()) SWIG_fail;
25389 }
25390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25391 return resultobj;
25392 fail:
25393 return NULL;
25394 }
25395
25396
25397 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25398 PyObject *resultobj = 0;
25399 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25400 wxWindow *arg2 = (wxWindow *) 0 ;
25401 void *argp1 = 0 ;
25402 int res1 = 0 ;
25403 void *argp2 = 0 ;
25404 int res2 = 0 ;
25405 PyObject * obj0 = 0 ;
25406 PyObject * obj1 = 0 ;
25407 char * kwnames[] = {
25408 (char *) "self",(char *) "win", NULL
25409 };
25410
25411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25413 if (!SWIG_IsOK(res1)) {
25414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25415 }
25416 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25418 if (!SWIG_IsOK(res2)) {
25419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25420 }
25421 arg2 = reinterpret_cast< wxWindow * >(argp2);
25422 {
25423 PyThreadState* __tstate = wxPyBeginAllowThreads();
25424 (arg1)->SetChangedWindow(arg2);
25425 wxPyEndAllowThreads(__tstate);
25426 if (PyErr_Occurred()) SWIG_fail;
25427 }
25428 resultobj = SWIG_Py_Void();
25429 return resultobj;
25430 fail:
25431 return NULL;
25432 }
25433
25434
25435 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25436 PyObject *resultobj = 0;
25437 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25438 wxWindow *result = 0 ;
25439 void *argp1 = 0 ;
25440 int res1 = 0 ;
25441 PyObject *swig_obj[1] ;
25442
25443 if (!args) SWIG_fail;
25444 swig_obj[0] = args;
25445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25446 if (!SWIG_IsOK(res1)) {
25447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25448 }
25449 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25450 {
25451 PyThreadState* __tstate = wxPyBeginAllowThreads();
25452 result = (wxWindow *)(arg1)->GetChangedWindow();
25453 wxPyEndAllowThreads(__tstate);
25454 if (PyErr_Occurred()) SWIG_fail;
25455 }
25456 {
25457 resultobj = wxPyMake_wxObject(result, (bool)0);
25458 }
25459 return resultobj;
25460 fail:
25461 return NULL;
25462 }
25463
25464
25465 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25466 PyObject *obj;
25467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25468 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25469 return SWIG_Py_Void();
25470 }
25471
25472 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25473 return SWIG_Python_InitShadowInstance(args);
25474 }
25475
25476 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25477 PyObject *resultobj = 0;
25478 int arg1 = (int) 0 ;
25479 wxQueryNewPaletteEvent *result = 0 ;
25480 int val1 ;
25481 int ecode1 = 0 ;
25482 PyObject * obj0 = 0 ;
25483 char * kwnames[] = {
25484 (char *) "winid", NULL
25485 };
25486
25487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25488 if (obj0) {
25489 ecode1 = SWIG_AsVal_int(obj0, &val1);
25490 if (!SWIG_IsOK(ecode1)) {
25491 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25492 }
25493 arg1 = static_cast< int >(val1);
25494 }
25495 {
25496 PyThreadState* __tstate = wxPyBeginAllowThreads();
25497 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25498 wxPyEndAllowThreads(__tstate);
25499 if (PyErr_Occurred()) SWIG_fail;
25500 }
25501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25502 return resultobj;
25503 fail:
25504 return NULL;
25505 }
25506
25507
25508 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25509 PyObject *resultobj = 0;
25510 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25511 bool arg2 ;
25512 void *argp1 = 0 ;
25513 int res1 = 0 ;
25514 bool val2 ;
25515 int ecode2 = 0 ;
25516 PyObject * obj0 = 0 ;
25517 PyObject * obj1 = 0 ;
25518 char * kwnames[] = {
25519 (char *) "self",(char *) "realized", NULL
25520 };
25521
25522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25524 if (!SWIG_IsOK(res1)) {
25525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25526 }
25527 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25528 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25529 if (!SWIG_IsOK(ecode2)) {
25530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25531 }
25532 arg2 = static_cast< bool >(val2);
25533 {
25534 PyThreadState* __tstate = wxPyBeginAllowThreads();
25535 (arg1)->SetPaletteRealized(arg2);
25536 wxPyEndAllowThreads(__tstate);
25537 if (PyErr_Occurred()) SWIG_fail;
25538 }
25539 resultobj = SWIG_Py_Void();
25540 return resultobj;
25541 fail:
25542 return NULL;
25543 }
25544
25545
25546 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25547 PyObject *resultobj = 0;
25548 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25549 bool result;
25550 void *argp1 = 0 ;
25551 int res1 = 0 ;
25552 PyObject *swig_obj[1] ;
25553
25554 if (!args) SWIG_fail;
25555 swig_obj[0] = args;
25556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25557 if (!SWIG_IsOK(res1)) {
25558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25559 }
25560 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25561 {
25562 PyThreadState* __tstate = wxPyBeginAllowThreads();
25563 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25564 wxPyEndAllowThreads(__tstate);
25565 if (PyErr_Occurred()) SWIG_fail;
25566 }
25567 {
25568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25569 }
25570 return resultobj;
25571 fail:
25572 return NULL;
25573 }
25574
25575
25576 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25577 PyObject *obj;
25578 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25579 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25580 return SWIG_Py_Void();
25581 }
25582
25583 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25584 return SWIG_Python_InitShadowInstance(args);
25585 }
25586
25587 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25588 PyObject *resultobj = 0;
25589 wxNavigationKeyEvent *result = 0 ;
25590
25591 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25592 {
25593 PyThreadState* __tstate = wxPyBeginAllowThreads();
25594 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25595 wxPyEndAllowThreads(__tstate);
25596 if (PyErr_Occurred()) SWIG_fail;
25597 }
25598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25599 return resultobj;
25600 fail:
25601 return NULL;
25602 }
25603
25604
25605 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25606 PyObject *resultobj = 0;
25607 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25608 bool result;
25609 void *argp1 = 0 ;
25610 int res1 = 0 ;
25611 PyObject *swig_obj[1] ;
25612
25613 if (!args) SWIG_fail;
25614 swig_obj[0] = args;
25615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25616 if (!SWIG_IsOK(res1)) {
25617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25618 }
25619 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25620 {
25621 PyThreadState* __tstate = wxPyBeginAllowThreads();
25622 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25623 wxPyEndAllowThreads(__tstate);
25624 if (PyErr_Occurred()) SWIG_fail;
25625 }
25626 {
25627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25628 }
25629 return resultobj;
25630 fail:
25631 return NULL;
25632 }
25633
25634
25635 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25636 PyObject *resultobj = 0;
25637 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25638 bool arg2 ;
25639 void *argp1 = 0 ;
25640 int res1 = 0 ;
25641 bool val2 ;
25642 int ecode2 = 0 ;
25643 PyObject * obj0 = 0 ;
25644 PyObject * obj1 = 0 ;
25645 char * kwnames[] = {
25646 (char *) "self",(char *) "forward", NULL
25647 };
25648
25649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25651 if (!SWIG_IsOK(res1)) {
25652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25653 }
25654 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25655 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25656 if (!SWIG_IsOK(ecode2)) {
25657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25658 }
25659 arg2 = static_cast< bool >(val2);
25660 {
25661 PyThreadState* __tstate = wxPyBeginAllowThreads();
25662 (arg1)->SetDirection(arg2);
25663 wxPyEndAllowThreads(__tstate);
25664 if (PyErr_Occurred()) SWIG_fail;
25665 }
25666 resultobj = SWIG_Py_Void();
25667 return resultobj;
25668 fail:
25669 return NULL;
25670 }
25671
25672
25673 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25674 PyObject *resultobj = 0;
25675 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25676 bool result;
25677 void *argp1 = 0 ;
25678 int res1 = 0 ;
25679 PyObject *swig_obj[1] ;
25680
25681 if (!args) SWIG_fail;
25682 swig_obj[0] = args;
25683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25684 if (!SWIG_IsOK(res1)) {
25685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25686 }
25687 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25688 {
25689 PyThreadState* __tstate = wxPyBeginAllowThreads();
25690 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25691 wxPyEndAllowThreads(__tstate);
25692 if (PyErr_Occurred()) SWIG_fail;
25693 }
25694 {
25695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25696 }
25697 return resultobj;
25698 fail:
25699 return NULL;
25700 }
25701
25702
25703 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25704 PyObject *resultobj = 0;
25705 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25706 bool arg2 ;
25707 void *argp1 = 0 ;
25708 int res1 = 0 ;
25709 bool val2 ;
25710 int ecode2 = 0 ;
25711 PyObject * obj0 = 0 ;
25712 PyObject * obj1 = 0 ;
25713 char * kwnames[] = {
25714 (char *) "self",(char *) "ischange", NULL
25715 };
25716
25717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25719 if (!SWIG_IsOK(res1)) {
25720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25721 }
25722 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25723 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25724 if (!SWIG_IsOK(ecode2)) {
25725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25726 }
25727 arg2 = static_cast< bool >(val2);
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 (arg1)->SetWindowChange(arg2);
25731 wxPyEndAllowThreads(__tstate);
25732 if (PyErr_Occurred()) SWIG_fail;
25733 }
25734 resultobj = SWIG_Py_Void();
25735 return resultobj;
25736 fail:
25737 return NULL;
25738 }
25739
25740
25741 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25742 PyObject *resultobj = 0;
25743 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25744 bool result;
25745 void *argp1 = 0 ;
25746 int res1 = 0 ;
25747 PyObject *swig_obj[1] ;
25748
25749 if (!args) SWIG_fail;
25750 swig_obj[0] = args;
25751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25752 if (!SWIG_IsOK(res1)) {
25753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25754 }
25755 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25756 {
25757 PyThreadState* __tstate = wxPyBeginAllowThreads();
25758 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25759 wxPyEndAllowThreads(__tstate);
25760 if (PyErr_Occurred()) SWIG_fail;
25761 }
25762 {
25763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25764 }
25765 return resultobj;
25766 fail:
25767 return NULL;
25768 }
25769
25770
25771 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25772 PyObject *resultobj = 0;
25773 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25774 bool arg2 ;
25775 void *argp1 = 0 ;
25776 int res1 = 0 ;
25777 bool val2 ;
25778 int ecode2 = 0 ;
25779 PyObject * obj0 = 0 ;
25780 PyObject * obj1 = 0 ;
25781 char * kwnames[] = {
25782 (char *) "self",(char *) "bIs", NULL
25783 };
25784
25785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25787 if (!SWIG_IsOK(res1)) {
25788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25789 }
25790 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25791 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25792 if (!SWIG_IsOK(ecode2)) {
25793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25794 }
25795 arg2 = static_cast< bool >(val2);
25796 {
25797 PyThreadState* __tstate = wxPyBeginAllowThreads();
25798 (arg1)->SetFromTab(arg2);
25799 wxPyEndAllowThreads(__tstate);
25800 if (PyErr_Occurred()) SWIG_fail;
25801 }
25802 resultobj = SWIG_Py_Void();
25803 return resultobj;
25804 fail:
25805 return NULL;
25806 }
25807
25808
25809 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25810 PyObject *resultobj = 0;
25811 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25812 long arg2 ;
25813 void *argp1 = 0 ;
25814 int res1 = 0 ;
25815 long val2 ;
25816 int ecode2 = 0 ;
25817 PyObject * obj0 = 0 ;
25818 PyObject * obj1 = 0 ;
25819 char * kwnames[] = {
25820 (char *) "self",(char *) "flags", NULL
25821 };
25822
25823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25825 if (!SWIG_IsOK(res1)) {
25826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25827 }
25828 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25829 ecode2 = SWIG_AsVal_long(obj1, &val2);
25830 if (!SWIG_IsOK(ecode2)) {
25831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25832 }
25833 arg2 = static_cast< long >(val2);
25834 {
25835 PyThreadState* __tstate = wxPyBeginAllowThreads();
25836 (arg1)->SetFlags(arg2);
25837 wxPyEndAllowThreads(__tstate);
25838 if (PyErr_Occurred()) SWIG_fail;
25839 }
25840 resultobj = SWIG_Py_Void();
25841 return resultobj;
25842 fail:
25843 return NULL;
25844 }
25845
25846
25847 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25848 PyObject *resultobj = 0;
25849 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25850 wxWindow *result = 0 ;
25851 void *argp1 = 0 ;
25852 int res1 = 0 ;
25853 PyObject *swig_obj[1] ;
25854
25855 if (!args) SWIG_fail;
25856 swig_obj[0] = args;
25857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25858 if (!SWIG_IsOK(res1)) {
25859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25860 }
25861 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25862 {
25863 PyThreadState* __tstate = wxPyBeginAllowThreads();
25864 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25865 wxPyEndAllowThreads(__tstate);
25866 if (PyErr_Occurred()) SWIG_fail;
25867 }
25868 {
25869 resultobj = wxPyMake_wxObject(result, (bool)0);
25870 }
25871 return resultobj;
25872 fail:
25873 return NULL;
25874 }
25875
25876
25877 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25878 PyObject *resultobj = 0;
25879 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25880 wxWindow *arg2 = (wxWindow *) 0 ;
25881 void *argp1 = 0 ;
25882 int res1 = 0 ;
25883 void *argp2 = 0 ;
25884 int res2 = 0 ;
25885 PyObject * obj0 = 0 ;
25886 PyObject * obj1 = 0 ;
25887 char * kwnames[] = {
25888 (char *) "self",(char *) "win", NULL
25889 };
25890
25891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25893 if (!SWIG_IsOK(res1)) {
25894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25895 }
25896 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25897 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25898 if (!SWIG_IsOK(res2)) {
25899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25900 }
25901 arg2 = reinterpret_cast< wxWindow * >(argp2);
25902 {
25903 PyThreadState* __tstate = wxPyBeginAllowThreads();
25904 (arg1)->SetCurrentFocus(arg2);
25905 wxPyEndAllowThreads(__tstate);
25906 if (PyErr_Occurred()) SWIG_fail;
25907 }
25908 resultobj = SWIG_Py_Void();
25909 return resultobj;
25910 fail:
25911 return NULL;
25912 }
25913
25914
25915 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25916 PyObject *obj;
25917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25918 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25919 return SWIG_Py_Void();
25920 }
25921
25922 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25923 return SWIG_Python_InitShadowInstance(args);
25924 }
25925
25926 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25927 PyObject *resultobj = 0;
25928 wxWindow *arg1 = (wxWindow *) NULL ;
25929 wxWindowCreateEvent *result = 0 ;
25930 void *argp1 = 0 ;
25931 int res1 = 0 ;
25932 PyObject * obj0 = 0 ;
25933 char * kwnames[] = {
25934 (char *) "win", NULL
25935 };
25936
25937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25938 if (obj0) {
25939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25940 if (!SWIG_IsOK(res1)) {
25941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25942 }
25943 arg1 = reinterpret_cast< wxWindow * >(argp1);
25944 }
25945 {
25946 PyThreadState* __tstate = wxPyBeginAllowThreads();
25947 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25948 wxPyEndAllowThreads(__tstate);
25949 if (PyErr_Occurred()) SWIG_fail;
25950 }
25951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25952 return resultobj;
25953 fail:
25954 return NULL;
25955 }
25956
25957
25958 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25959 PyObject *resultobj = 0;
25960 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25961 wxWindow *result = 0 ;
25962 void *argp1 = 0 ;
25963 int res1 = 0 ;
25964 PyObject *swig_obj[1] ;
25965
25966 if (!args) SWIG_fail;
25967 swig_obj[0] = args;
25968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25969 if (!SWIG_IsOK(res1)) {
25970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25971 }
25972 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25973 {
25974 PyThreadState* __tstate = wxPyBeginAllowThreads();
25975 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25976 wxPyEndAllowThreads(__tstate);
25977 if (PyErr_Occurred()) SWIG_fail;
25978 }
25979 {
25980 resultobj = wxPyMake_wxObject(result, (bool)0);
25981 }
25982 return resultobj;
25983 fail:
25984 return NULL;
25985 }
25986
25987
25988 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25989 PyObject *obj;
25990 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25991 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25992 return SWIG_Py_Void();
25993 }
25994
25995 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25996 return SWIG_Python_InitShadowInstance(args);
25997 }
25998
25999 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26000 PyObject *resultobj = 0;
26001 wxWindow *arg1 = (wxWindow *) NULL ;
26002 wxWindowDestroyEvent *result = 0 ;
26003 void *argp1 = 0 ;
26004 int res1 = 0 ;
26005 PyObject * obj0 = 0 ;
26006 char * kwnames[] = {
26007 (char *) "win", NULL
26008 };
26009
26010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26011 if (obj0) {
26012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26013 if (!SWIG_IsOK(res1)) {
26014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26015 }
26016 arg1 = reinterpret_cast< wxWindow * >(argp1);
26017 }
26018 {
26019 PyThreadState* __tstate = wxPyBeginAllowThreads();
26020 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26021 wxPyEndAllowThreads(__tstate);
26022 if (PyErr_Occurred()) SWIG_fail;
26023 }
26024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26025 return resultobj;
26026 fail:
26027 return NULL;
26028 }
26029
26030
26031 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26032 PyObject *resultobj = 0;
26033 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26034 wxWindow *result = 0 ;
26035 void *argp1 = 0 ;
26036 int res1 = 0 ;
26037 PyObject *swig_obj[1] ;
26038
26039 if (!args) SWIG_fail;
26040 swig_obj[0] = args;
26041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26042 if (!SWIG_IsOK(res1)) {
26043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26044 }
26045 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26049 wxPyEndAllowThreads(__tstate);
26050 if (PyErr_Occurred()) SWIG_fail;
26051 }
26052 {
26053 resultobj = wxPyMake_wxObject(result, (bool)0);
26054 }
26055 return resultobj;
26056 fail:
26057 return NULL;
26058 }
26059
26060
26061 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26062 PyObject *obj;
26063 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26064 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26065 return SWIG_Py_Void();
26066 }
26067
26068 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26069 return SWIG_Python_InitShadowInstance(args);
26070 }
26071
26072 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26073 PyObject *resultobj = 0;
26074 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26075 int arg2 = (int) 0 ;
26076 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26077 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26078 wxContextMenuEvent *result = 0 ;
26079 int val1 ;
26080 int ecode1 = 0 ;
26081 int val2 ;
26082 int ecode2 = 0 ;
26083 wxPoint temp3 ;
26084 PyObject * obj0 = 0 ;
26085 PyObject * obj1 = 0 ;
26086 PyObject * obj2 = 0 ;
26087 char * kwnames[] = {
26088 (char *) "type",(char *) "winid",(char *) "pt", NULL
26089 };
26090
26091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26092 if (obj0) {
26093 ecode1 = SWIG_AsVal_int(obj0, &val1);
26094 if (!SWIG_IsOK(ecode1)) {
26095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26096 }
26097 arg1 = static_cast< wxEventType >(val1);
26098 }
26099 if (obj1) {
26100 ecode2 = SWIG_AsVal_int(obj1, &val2);
26101 if (!SWIG_IsOK(ecode2)) {
26102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26103 }
26104 arg2 = static_cast< int >(val2);
26105 }
26106 if (obj2) {
26107 {
26108 arg3 = &temp3;
26109 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26110 }
26111 }
26112 {
26113 PyThreadState* __tstate = wxPyBeginAllowThreads();
26114 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26115 wxPyEndAllowThreads(__tstate);
26116 if (PyErr_Occurred()) SWIG_fail;
26117 }
26118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26119 return resultobj;
26120 fail:
26121 return NULL;
26122 }
26123
26124
26125 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26126 PyObject *resultobj = 0;
26127 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26128 wxPoint *result = 0 ;
26129 void *argp1 = 0 ;
26130 int res1 = 0 ;
26131 PyObject *swig_obj[1] ;
26132
26133 if (!args) SWIG_fail;
26134 swig_obj[0] = args;
26135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26136 if (!SWIG_IsOK(res1)) {
26137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26138 }
26139 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26140 {
26141 PyThreadState* __tstate = wxPyBeginAllowThreads();
26142 {
26143 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26144 result = (wxPoint *) &_result_ref;
26145 }
26146 wxPyEndAllowThreads(__tstate);
26147 if (PyErr_Occurred()) SWIG_fail;
26148 }
26149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26150 return resultobj;
26151 fail:
26152 return NULL;
26153 }
26154
26155
26156 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26157 PyObject *resultobj = 0;
26158 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26159 wxPoint *arg2 = 0 ;
26160 void *argp1 = 0 ;
26161 int res1 = 0 ;
26162 wxPoint temp2 ;
26163 PyObject * obj0 = 0 ;
26164 PyObject * obj1 = 0 ;
26165 char * kwnames[] = {
26166 (char *) "self",(char *) "pos", NULL
26167 };
26168
26169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26171 if (!SWIG_IsOK(res1)) {
26172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26173 }
26174 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26175 {
26176 arg2 = &temp2;
26177 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26178 }
26179 {
26180 PyThreadState* __tstate = wxPyBeginAllowThreads();
26181 (arg1)->SetPosition((wxPoint const &)*arg2);
26182 wxPyEndAllowThreads(__tstate);
26183 if (PyErr_Occurred()) SWIG_fail;
26184 }
26185 resultobj = SWIG_Py_Void();
26186 return resultobj;
26187 fail:
26188 return NULL;
26189 }
26190
26191
26192 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26193 PyObject *obj;
26194 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26195 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26196 return SWIG_Py_Void();
26197 }
26198
26199 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26200 return SWIG_Python_InitShadowInstance(args);
26201 }
26202
26203 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26204 PyObject *resultobj = 0;
26205 wxIdleEvent *result = 0 ;
26206
26207 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26208 {
26209 PyThreadState* __tstate = wxPyBeginAllowThreads();
26210 result = (wxIdleEvent *)new wxIdleEvent();
26211 wxPyEndAllowThreads(__tstate);
26212 if (PyErr_Occurred()) SWIG_fail;
26213 }
26214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26222 PyObject *resultobj = 0;
26223 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26224 bool arg2 = (bool) true ;
26225 void *argp1 = 0 ;
26226 int res1 = 0 ;
26227 bool val2 ;
26228 int ecode2 = 0 ;
26229 PyObject * obj0 = 0 ;
26230 PyObject * obj1 = 0 ;
26231 char * kwnames[] = {
26232 (char *) "self",(char *) "needMore", NULL
26233 };
26234
26235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26237 if (!SWIG_IsOK(res1)) {
26238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26239 }
26240 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26241 if (obj1) {
26242 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26243 if (!SWIG_IsOK(ecode2)) {
26244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26245 }
26246 arg2 = static_cast< bool >(val2);
26247 }
26248 {
26249 PyThreadState* __tstate = wxPyBeginAllowThreads();
26250 (arg1)->RequestMore(arg2);
26251 wxPyEndAllowThreads(__tstate);
26252 if (PyErr_Occurred()) SWIG_fail;
26253 }
26254 resultobj = SWIG_Py_Void();
26255 return resultobj;
26256 fail:
26257 return NULL;
26258 }
26259
26260
26261 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26262 PyObject *resultobj = 0;
26263 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26264 bool result;
26265 void *argp1 = 0 ;
26266 int res1 = 0 ;
26267 PyObject *swig_obj[1] ;
26268
26269 if (!args) SWIG_fail;
26270 swig_obj[0] = args;
26271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26272 if (!SWIG_IsOK(res1)) {
26273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26274 }
26275 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26276 {
26277 PyThreadState* __tstate = wxPyBeginAllowThreads();
26278 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26279 wxPyEndAllowThreads(__tstate);
26280 if (PyErr_Occurred()) SWIG_fail;
26281 }
26282 {
26283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26284 }
26285 return resultobj;
26286 fail:
26287 return NULL;
26288 }
26289
26290
26291 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26292 PyObject *resultobj = 0;
26293 wxIdleMode arg1 ;
26294 int val1 ;
26295 int ecode1 = 0 ;
26296 PyObject * obj0 = 0 ;
26297 char * kwnames[] = {
26298 (char *) "mode", NULL
26299 };
26300
26301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26302 ecode1 = SWIG_AsVal_int(obj0, &val1);
26303 if (!SWIG_IsOK(ecode1)) {
26304 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26305 }
26306 arg1 = static_cast< wxIdleMode >(val1);
26307 {
26308 PyThreadState* __tstate = wxPyBeginAllowThreads();
26309 wxIdleEvent::SetMode(arg1);
26310 wxPyEndAllowThreads(__tstate);
26311 if (PyErr_Occurred()) SWIG_fail;
26312 }
26313 resultobj = SWIG_Py_Void();
26314 return resultobj;
26315 fail:
26316 return NULL;
26317 }
26318
26319
26320 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26321 PyObject *resultobj = 0;
26322 wxIdleMode result;
26323
26324 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26325 {
26326 PyThreadState* __tstate = wxPyBeginAllowThreads();
26327 result = (wxIdleMode)wxIdleEvent::GetMode();
26328 wxPyEndAllowThreads(__tstate);
26329 if (PyErr_Occurred()) SWIG_fail;
26330 }
26331 resultobj = SWIG_From_int(static_cast< int >(result));
26332 return resultobj;
26333 fail:
26334 return NULL;
26335 }
26336
26337
26338 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26339 PyObject *resultobj = 0;
26340 wxWindow *arg1 = (wxWindow *) 0 ;
26341 bool result;
26342 void *argp1 = 0 ;
26343 int res1 = 0 ;
26344 PyObject * obj0 = 0 ;
26345 char * kwnames[] = {
26346 (char *) "win", NULL
26347 };
26348
26349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26351 if (!SWIG_IsOK(res1)) {
26352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26353 }
26354 arg1 = reinterpret_cast< wxWindow * >(argp1);
26355 {
26356 PyThreadState* __tstate = wxPyBeginAllowThreads();
26357 result = (bool)wxIdleEvent::CanSend(arg1);
26358 wxPyEndAllowThreads(__tstate);
26359 if (PyErr_Occurred()) SWIG_fail;
26360 }
26361 {
26362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26363 }
26364 return resultobj;
26365 fail:
26366 return NULL;
26367 }
26368
26369
26370 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26371 PyObject *obj;
26372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26373 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26374 return SWIG_Py_Void();
26375 }
26376
26377 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26378 return SWIG_Python_InitShadowInstance(args);
26379 }
26380
26381 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26382 PyObject *resultobj = 0;
26383 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26384 int arg2 = (int) 0 ;
26385 wxClipboardTextEvent *result = 0 ;
26386 int val1 ;
26387 int ecode1 = 0 ;
26388 int val2 ;
26389 int ecode2 = 0 ;
26390 PyObject * obj0 = 0 ;
26391 PyObject * obj1 = 0 ;
26392 char * kwnames[] = {
26393 (char *) "type",(char *) "winid", NULL
26394 };
26395
26396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26397 if (obj0) {
26398 ecode1 = SWIG_AsVal_int(obj0, &val1);
26399 if (!SWIG_IsOK(ecode1)) {
26400 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26401 }
26402 arg1 = static_cast< wxEventType >(val1);
26403 }
26404 if (obj1) {
26405 ecode2 = SWIG_AsVal_int(obj1, &val2);
26406 if (!SWIG_IsOK(ecode2)) {
26407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26408 }
26409 arg2 = static_cast< int >(val2);
26410 }
26411 {
26412 PyThreadState* __tstate = wxPyBeginAllowThreads();
26413 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26414 wxPyEndAllowThreads(__tstate);
26415 if (PyErr_Occurred()) SWIG_fail;
26416 }
26417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26418 return resultobj;
26419 fail:
26420 return NULL;
26421 }
26422
26423
26424 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26425 PyObject *obj;
26426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26427 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26428 return SWIG_Py_Void();
26429 }
26430
26431 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26432 return SWIG_Python_InitShadowInstance(args);
26433 }
26434
26435 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26436 PyObject *resultobj = 0;
26437 int arg1 = (int) 0 ;
26438 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26439 wxPyEvent *result = 0 ;
26440 int val1 ;
26441 int ecode1 = 0 ;
26442 int val2 ;
26443 int ecode2 = 0 ;
26444 PyObject * obj0 = 0 ;
26445 PyObject * obj1 = 0 ;
26446 char * kwnames[] = {
26447 (char *) "winid",(char *) "eventType", NULL
26448 };
26449
26450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26451 if (obj0) {
26452 ecode1 = SWIG_AsVal_int(obj0, &val1);
26453 if (!SWIG_IsOK(ecode1)) {
26454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26455 }
26456 arg1 = static_cast< int >(val1);
26457 }
26458 if (obj1) {
26459 ecode2 = SWIG_AsVal_int(obj1, &val2);
26460 if (!SWIG_IsOK(ecode2)) {
26461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26462 }
26463 arg2 = static_cast< wxEventType >(val2);
26464 }
26465 {
26466 PyThreadState* __tstate = wxPyBeginAllowThreads();
26467 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26468 wxPyEndAllowThreads(__tstate);
26469 if (PyErr_Occurred()) SWIG_fail;
26470 }
26471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26472 return resultobj;
26473 fail:
26474 return NULL;
26475 }
26476
26477
26478 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26479 PyObject *resultobj = 0;
26480 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26481 void *argp1 = 0 ;
26482 int res1 = 0 ;
26483 PyObject *swig_obj[1] ;
26484
26485 if (!args) SWIG_fail;
26486 swig_obj[0] = args;
26487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26488 if (!SWIG_IsOK(res1)) {
26489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26490 }
26491 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26492 {
26493 PyThreadState* __tstate = wxPyBeginAllowThreads();
26494 delete arg1;
26495
26496 wxPyEndAllowThreads(__tstate);
26497 if (PyErr_Occurred()) SWIG_fail;
26498 }
26499 resultobj = SWIG_Py_Void();
26500 return resultobj;
26501 fail:
26502 return NULL;
26503 }
26504
26505
26506 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26507 PyObject *resultobj = 0;
26508 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26509 PyObject *arg2 = (PyObject *) 0 ;
26510 void *argp1 = 0 ;
26511 int res1 = 0 ;
26512 PyObject * obj0 = 0 ;
26513 PyObject * obj1 = 0 ;
26514 char * kwnames[] = {
26515 (char *) "self",(char *) "self", NULL
26516 };
26517
26518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26520 if (!SWIG_IsOK(res1)) {
26521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26522 }
26523 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26524 arg2 = obj1;
26525 {
26526 PyThreadState* __tstate = wxPyBeginAllowThreads();
26527 (arg1)->SetSelf(arg2);
26528 wxPyEndAllowThreads(__tstate);
26529 if (PyErr_Occurred()) SWIG_fail;
26530 }
26531 resultobj = SWIG_Py_Void();
26532 return resultobj;
26533 fail:
26534 return NULL;
26535 }
26536
26537
26538 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26539 PyObject *resultobj = 0;
26540 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26541 PyObject *result = 0 ;
26542 void *argp1 = 0 ;
26543 int res1 = 0 ;
26544 PyObject *swig_obj[1] ;
26545
26546 if (!args) SWIG_fail;
26547 swig_obj[0] = args;
26548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26549 if (!SWIG_IsOK(res1)) {
26550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26551 }
26552 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26553 {
26554 PyThreadState* __tstate = wxPyBeginAllowThreads();
26555 result = (PyObject *)(arg1)->GetSelf();
26556 wxPyEndAllowThreads(__tstate);
26557 if (PyErr_Occurred()) SWIG_fail;
26558 }
26559 resultobj = result;
26560 return resultobj;
26561 fail:
26562 return NULL;
26563 }
26564
26565
26566 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26567 PyObject *obj;
26568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26569 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26570 return SWIG_Py_Void();
26571 }
26572
26573 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26574 return SWIG_Python_InitShadowInstance(args);
26575 }
26576
26577 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26578 PyObject *resultobj = 0;
26579 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26580 int arg2 = (int) 0 ;
26581 wxPyCommandEvent *result = 0 ;
26582 int val1 ;
26583 int ecode1 = 0 ;
26584 int val2 ;
26585 int ecode2 = 0 ;
26586 PyObject * obj0 = 0 ;
26587 PyObject * obj1 = 0 ;
26588 char * kwnames[] = {
26589 (char *) "eventType",(char *) "id", NULL
26590 };
26591
26592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26593 if (obj0) {
26594 ecode1 = SWIG_AsVal_int(obj0, &val1);
26595 if (!SWIG_IsOK(ecode1)) {
26596 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26597 }
26598 arg1 = static_cast< wxEventType >(val1);
26599 }
26600 if (obj1) {
26601 ecode2 = SWIG_AsVal_int(obj1, &val2);
26602 if (!SWIG_IsOK(ecode2)) {
26603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26604 }
26605 arg2 = static_cast< int >(val2);
26606 }
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26610 wxPyEndAllowThreads(__tstate);
26611 if (PyErr_Occurred()) SWIG_fail;
26612 }
26613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26614 return resultobj;
26615 fail:
26616 return NULL;
26617 }
26618
26619
26620 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26621 PyObject *resultobj = 0;
26622 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26623 void *argp1 = 0 ;
26624 int res1 = 0 ;
26625 PyObject *swig_obj[1] ;
26626
26627 if (!args) SWIG_fail;
26628 swig_obj[0] = args;
26629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26630 if (!SWIG_IsOK(res1)) {
26631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26632 }
26633 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26634 {
26635 PyThreadState* __tstate = wxPyBeginAllowThreads();
26636 delete arg1;
26637
26638 wxPyEndAllowThreads(__tstate);
26639 if (PyErr_Occurred()) SWIG_fail;
26640 }
26641 resultobj = SWIG_Py_Void();
26642 return resultobj;
26643 fail:
26644 return NULL;
26645 }
26646
26647
26648 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26649 PyObject *resultobj = 0;
26650 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26651 PyObject *arg2 = (PyObject *) 0 ;
26652 void *argp1 = 0 ;
26653 int res1 = 0 ;
26654 PyObject * obj0 = 0 ;
26655 PyObject * obj1 = 0 ;
26656 char * kwnames[] = {
26657 (char *) "self",(char *) "self", NULL
26658 };
26659
26660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26662 if (!SWIG_IsOK(res1)) {
26663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26664 }
26665 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26666 arg2 = obj1;
26667 {
26668 PyThreadState* __tstate = wxPyBeginAllowThreads();
26669 (arg1)->SetSelf(arg2);
26670 wxPyEndAllowThreads(__tstate);
26671 if (PyErr_Occurred()) SWIG_fail;
26672 }
26673 resultobj = SWIG_Py_Void();
26674 return resultobj;
26675 fail:
26676 return NULL;
26677 }
26678
26679
26680 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26681 PyObject *resultobj = 0;
26682 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26683 PyObject *result = 0 ;
26684 void *argp1 = 0 ;
26685 int res1 = 0 ;
26686 PyObject *swig_obj[1] ;
26687
26688 if (!args) SWIG_fail;
26689 swig_obj[0] = args;
26690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26691 if (!SWIG_IsOK(res1)) {
26692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26693 }
26694 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26695 {
26696 PyThreadState* __tstate = wxPyBeginAllowThreads();
26697 result = (PyObject *)(arg1)->GetSelf();
26698 wxPyEndAllowThreads(__tstate);
26699 if (PyErr_Occurred()) SWIG_fail;
26700 }
26701 resultobj = result;
26702 return resultobj;
26703 fail:
26704 return NULL;
26705 }
26706
26707
26708 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26709 PyObject *obj;
26710 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26711 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26712 return SWIG_Py_Void();
26713 }
26714
26715 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26716 return SWIG_Python_InitShadowInstance(args);
26717 }
26718
26719 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26720 PyObject *resultobj = 0;
26721 wxWindow *arg1 = (wxWindow *) 0 ;
26722 wxDateTime *arg2 = 0 ;
26723 wxEventType arg3 ;
26724 wxDateEvent *result = 0 ;
26725 void *argp1 = 0 ;
26726 int res1 = 0 ;
26727 void *argp2 = 0 ;
26728 int res2 = 0 ;
26729 int val3 ;
26730 int ecode3 = 0 ;
26731 PyObject * obj0 = 0 ;
26732 PyObject * obj1 = 0 ;
26733 PyObject * obj2 = 0 ;
26734 char * kwnames[] = {
26735 (char *) "win",(char *) "dt",(char *) "type", NULL
26736 };
26737
26738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26740 if (!SWIG_IsOK(res1)) {
26741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26742 }
26743 arg1 = reinterpret_cast< wxWindow * >(argp1);
26744 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26745 if (!SWIG_IsOK(res2)) {
26746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26747 }
26748 if (!argp2) {
26749 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26750 }
26751 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26752 ecode3 = SWIG_AsVal_int(obj2, &val3);
26753 if (!SWIG_IsOK(ecode3)) {
26754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26755 }
26756 arg3 = static_cast< wxEventType >(val3);
26757 {
26758 PyThreadState* __tstate = wxPyBeginAllowThreads();
26759 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26760 wxPyEndAllowThreads(__tstate);
26761 if (PyErr_Occurred()) SWIG_fail;
26762 }
26763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26764 return resultobj;
26765 fail:
26766 return NULL;
26767 }
26768
26769
26770 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26771 PyObject *resultobj = 0;
26772 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26773 wxDateTime *result = 0 ;
26774 void *argp1 = 0 ;
26775 int res1 = 0 ;
26776 PyObject *swig_obj[1] ;
26777
26778 if (!args) SWIG_fail;
26779 swig_obj[0] = args;
26780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26781 if (!SWIG_IsOK(res1)) {
26782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26783 }
26784 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26785 {
26786 PyThreadState* __tstate = wxPyBeginAllowThreads();
26787 {
26788 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26789 result = (wxDateTime *) &_result_ref;
26790 }
26791 wxPyEndAllowThreads(__tstate);
26792 if (PyErr_Occurred()) SWIG_fail;
26793 }
26794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26795 return resultobj;
26796 fail:
26797 return NULL;
26798 }
26799
26800
26801 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26802 PyObject *resultobj = 0;
26803 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26804 wxDateTime *arg2 = 0 ;
26805 void *argp1 = 0 ;
26806 int res1 = 0 ;
26807 void *argp2 = 0 ;
26808 int res2 = 0 ;
26809 PyObject * obj0 = 0 ;
26810 PyObject * obj1 = 0 ;
26811 char * kwnames[] = {
26812 (char *) "self",(char *) "date", NULL
26813 };
26814
26815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26817 if (!SWIG_IsOK(res1)) {
26818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26819 }
26820 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26821 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26822 if (!SWIG_IsOK(res2)) {
26823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26824 }
26825 if (!argp2) {
26826 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26827 }
26828 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26829 {
26830 PyThreadState* __tstate = wxPyBeginAllowThreads();
26831 (arg1)->SetDate((wxDateTime const &)*arg2);
26832 wxPyEndAllowThreads(__tstate);
26833 if (PyErr_Occurred()) SWIG_fail;
26834 }
26835 resultobj = SWIG_Py_Void();
26836 return resultobj;
26837 fail:
26838 return NULL;
26839 }
26840
26841
26842 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26843 PyObject *obj;
26844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26845 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26846 return SWIG_Py_Void();
26847 }
26848
26849 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26850 return SWIG_Python_InitShadowInstance(args);
26851 }
26852
26853 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26854 PyObject *resultobj = 0;
26855 wxPyApp *result = 0 ;
26856
26857 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26858 {
26859 PyThreadState* __tstate = wxPyBeginAllowThreads();
26860 result = (wxPyApp *)new_wxPyApp();
26861 wxPyEndAllowThreads(__tstate);
26862 if (PyErr_Occurred()) SWIG_fail;
26863 }
26864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26865 return resultobj;
26866 fail:
26867 return NULL;
26868 }
26869
26870
26871 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26872 PyObject *resultobj = 0;
26873 wxPyApp *arg1 = (wxPyApp *) 0 ;
26874 void *argp1 = 0 ;
26875 int res1 = 0 ;
26876 PyObject *swig_obj[1] ;
26877
26878 if (!args) SWIG_fail;
26879 swig_obj[0] = args;
26880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26881 if (!SWIG_IsOK(res1)) {
26882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26883 }
26884 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26885 {
26886 PyThreadState* __tstate = wxPyBeginAllowThreads();
26887 delete arg1;
26888
26889 wxPyEndAllowThreads(__tstate);
26890 if (PyErr_Occurred()) SWIG_fail;
26891 }
26892 resultobj = SWIG_Py_Void();
26893 return resultobj;
26894 fail:
26895 return NULL;
26896 }
26897
26898
26899 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26900 PyObject *resultobj = 0;
26901 wxPyApp *arg1 = (wxPyApp *) 0 ;
26902 PyObject *arg2 = (PyObject *) 0 ;
26903 PyObject *arg3 = (PyObject *) 0 ;
26904 bool arg4 ;
26905 void *argp1 = 0 ;
26906 int res1 = 0 ;
26907 bool val4 ;
26908 int ecode4 = 0 ;
26909 PyObject * obj0 = 0 ;
26910 PyObject * obj1 = 0 ;
26911 PyObject * obj2 = 0 ;
26912 PyObject * obj3 = 0 ;
26913 char * kwnames[] = {
26914 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26915 };
26916
26917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26919 if (!SWIG_IsOK(res1)) {
26920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26921 }
26922 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26923 arg2 = obj1;
26924 arg3 = obj2;
26925 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26926 if (!SWIG_IsOK(ecode4)) {
26927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26928 }
26929 arg4 = static_cast< bool >(val4);
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26933 wxPyEndAllowThreads(__tstate);
26934 if (PyErr_Occurred()) SWIG_fail;
26935 }
26936 resultobj = SWIG_Py_Void();
26937 return resultobj;
26938 fail:
26939 return NULL;
26940 }
26941
26942
26943 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26944 PyObject *resultobj = 0;
26945 wxPyApp *arg1 = (wxPyApp *) 0 ;
26946 wxString result;
26947 void *argp1 = 0 ;
26948 int res1 = 0 ;
26949 PyObject *swig_obj[1] ;
26950
26951 if (!args) SWIG_fail;
26952 swig_obj[0] = args;
26953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26954 if (!SWIG_IsOK(res1)) {
26955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26956 }
26957 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26958 {
26959 PyThreadState* __tstate = wxPyBeginAllowThreads();
26960 result = ((wxPyApp const *)arg1)->GetAppName();
26961 wxPyEndAllowThreads(__tstate);
26962 if (PyErr_Occurred()) SWIG_fail;
26963 }
26964 {
26965 #if wxUSE_UNICODE
26966 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26967 #else
26968 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26969 #endif
26970 }
26971 return resultobj;
26972 fail:
26973 return NULL;
26974 }
26975
26976
26977 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26978 PyObject *resultobj = 0;
26979 wxPyApp *arg1 = (wxPyApp *) 0 ;
26980 wxString *arg2 = 0 ;
26981 void *argp1 = 0 ;
26982 int res1 = 0 ;
26983 bool temp2 = false ;
26984 PyObject * obj0 = 0 ;
26985 PyObject * obj1 = 0 ;
26986 char * kwnames[] = {
26987 (char *) "self",(char *) "name", NULL
26988 };
26989
26990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26992 if (!SWIG_IsOK(res1)) {
26993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26994 }
26995 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26996 {
26997 arg2 = wxString_in_helper(obj1);
26998 if (arg2 == NULL) SWIG_fail;
26999 temp2 = true;
27000 }
27001 {
27002 PyThreadState* __tstate = wxPyBeginAllowThreads();
27003 (arg1)->SetAppName((wxString const &)*arg2);
27004 wxPyEndAllowThreads(__tstate);
27005 if (PyErr_Occurred()) SWIG_fail;
27006 }
27007 resultobj = SWIG_Py_Void();
27008 {
27009 if (temp2)
27010 delete arg2;
27011 }
27012 return resultobj;
27013 fail:
27014 {
27015 if (temp2)
27016 delete arg2;
27017 }
27018 return NULL;
27019 }
27020
27021
27022 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27023 PyObject *resultobj = 0;
27024 wxPyApp *arg1 = (wxPyApp *) 0 ;
27025 wxString result;
27026 void *argp1 = 0 ;
27027 int res1 = 0 ;
27028 PyObject *swig_obj[1] ;
27029
27030 if (!args) SWIG_fail;
27031 swig_obj[0] = args;
27032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27033 if (!SWIG_IsOK(res1)) {
27034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27035 }
27036 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27037 {
27038 PyThreadState* __tstate = wxPyBeginAllowThreads();
27039 result = ((wxPyApp const *)arg1)->GetClassName();
27040 wxPyEndAllowThreads(__tstate);
27041 if (PyErr_Occurred()) SWIG_fail;
27042 }
27043 {
27044 #if wxUSE_UNICODE
27045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27046 #else
27047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27048 #endif
27049 }
27050 return resultobj;
27051 fail:
27052 return NULL;
27053 }
27054
27055
27056 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27057 PyObject *resultobj = 0;
27058 wxPyApp *arg1 = (wxPyApp *) 0 ;
27059 wxString *arg2 = 0 ;
27060 void *argp1 = 0 ;
27061 int res1 = 0 ;
27062 bool temp2 = false ;
27063 PyObject * obj0 = 0 ;
27064 PyObject * obj1 = 0 ;
27065 char * kwnames[] = {
27066 (char *) "self",(char *) "name", NULL
27067 };
27068
27069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27071 if (!SWIG_IsOK(res1)) {
27072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27073 }
27074 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27075 {
27076 arg2 = wxString_in_helper(obj1);
27077 if (arg2 == NULL) SWIG_fail;
27078 temp2 = true;
27079 }
27080 {
27081 PyThreadState* __tstate = wxPyBeginAllowThreads();
27082 (arg1)->SetClassName((wxString const &)*arg2);
27083 wxPyEndAllowThreads(__tstate);
27084 if (PyErr_Occurred()) SWIG_fail;
27085 }
27086 resultobj = SWIG_Py_Void();
27087 {
27088 if (temp2)
27089 delete arg2;
27090 }
27091 return resultobj;
27092 fail:
27093 {
27094 if (temp2)
27095 delete arg2;
27096 }
27097 return NULL;
27098 }
27099
27100
27101 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27102 PyObject *resultobj = 0;
27103 wxPyApp *arg1 = (wxPyApp *) 0 ;
27104 wxString *result = 0 ;
27105 void *argp1 = 0 ;
27106 int res1 = 0 ;
27107 PyObject *swig_obj[1] ;
27108
27109 if (!args) SWIG_fail;
27110 swig_obj[0] = args;
27111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27112 if (!SWIG_IsOK(res1)) {
27113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27114 }
27115 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27116 {
27117 PyThreadState* __tstate = wxPyBeginAllowThreads();
27118 {
27119 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27120 result = (wxString *) &_result_ref;
27121 }
27122 wxPyEndAllowThreads(__tstate);
27123 if (PyErr_Occurred()) SWIG_fail;
27124 }
27125 {
27126 #if wxUSE_UNICODE
27127 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27128 #else
27129 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27130 #endif
27131 }
27132 return resultobj;
27133 fail:
27134 return NULL;
27135 }
27136
27137
27138 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27139 PyObject *resultobj = 0;
27140 wxPyApp *arg1 = (wxPyApp *) 0 ;
27141 wxString *arg2 = 0 ;
27142 void *argp1 = 0 ;
27143 int res1 = 0 ;
27144 bool temp2 = false ;
27145 PyObject * obj0 = 0 ;
27146 PyObject * obj1 = 0 ;
27147 char * kwnames[] = {
27148 (char *) "self",(char *) "name", NULL
27149 };
27150
27151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27153 if (!SWIG_IsOK(res1)) {
27154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27155 }
27156 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27157 {
27158 arg2 = wxString_in_helper(obj1);
27159 if (arg2 == NULL) SWIG_fail;
27160 temp2 = true;
27161 }
27162 {
27163 PyThreadState* __tstate = wxPyBeginAllowThreads();
27164 (arg1)->SetVendorName((wxString const &)*arg2);
27165 wxPyEndAllowThreads(__tstate);
27166 if (PyErr_Occurred()) SWIG_fail;
27167 }
27168 resultobj = SWIG_Py_Void();
27169 {
27170 if (temp2)
27171 delete arg2;
27172 }
27173 return resultobj;
27174 fail:
27175 {
27176 if (temp2)
27177 delete arg2;
27178 }
27179 return NULL;
27180 }
27181
27182
27183 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27184 PyObject *resultobj = 0;
27185 wxPyApp *arg1 = (wxPyApp *) 0 ;
27186 wxAppTraits *result = 0 ;
27187 void *argp1 = 0 ;
27188 int res1 = 0 ;
27189 PyObject *swig_obj[1] ;
27190
27191 if (!args) SWIG_fail;
27192 swig_obj[0] = args;
27193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27194 if (!SWIG_IsOK(res1)) {
27195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27196 }
27197 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27198 {
27199 PyThreadState* __tstate = wxPyBeginAllowThreads();
27200 result = (wxAppTraits *)(arg1)->GetTraits();
27201 wxPyEndAllowThreads(__tstate);
27202 if (PyErr_Occurred()) SWIG_fail;
27203 }
27204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27205 return resultobj;
27206 fail:
27207 return NULL;
27208 }
27209
27210
27211 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27212 PyObject *resultobj = 0;
27213 wxPyApp *arg1 = (wxPyApp *) 0 ;
27214 void *argp1 = 0 ;
27215 int res1 = 0 ;
27216 PyObject *swig_obj[1] ;
27217
27218 if (!args) SWIG_fail;
27219 swig_obj[0] = args;
27220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27221 if (!SWIG_IsOK(res1)) {
27222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27223 }
27224 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27225 {
27226 PyThreadState* __tstate = wxPyBeginAllowThreads();
27227 (arg1)->ProcessPendingEvents();
27228 wxPyEndAllowThreads(__tstate);
27229 if (PyErr_Occurred()) SWIG_fail;
27230 }
27231 resultobj = SWIG_Py_Void();
27232 return resultobj;
27233 fail:
27234 return NULL;
27235 }
27236
27237
27238 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27239 PyObject *resultobj = 0;
27240 wxPyApp *arg1 = (wxPyApp *) 0 ;
27241 bool arg2 = (bool) false ;
27242 bool result;
27243 void *argp1 = 0 ;
27244 int res1 = 0 ;
27245 bool val2 ;
27246 int ecode2 = 0 ;
27247 PyObject * obj0 = 0 ;
27248 PyObject * obj1 = 0 ;
27249 char * kwnames[] = {
27250 (char *) "self",(char *) "onlyIfNeeded", NULL
27251 };
27252
27253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27255 if (!SWIG_IsOK(res1)) {
27256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27257 }
27258 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27259 if (obj1) {
27260 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27261 if (!SWIG_IsOK(ecode2)) {
27262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27263 }
27264 arg2 = static_cast< bool >(val2);
27265 }
27266 {
27267 PyThreadState* __tstate = wxPyBeginAllowThreads();
27268 result = (bool)(arg1)->Yield(arg2);
27269 wxPyEndAllowThreads(__tstate);
27270 if (PyErr_Occurred()) SWIG_fail;
27271 }
27272 {
27273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27274 }
27275 return resultobj;
27276 fail:
27277 return NULL;
27278 }
27279
27280
27281 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27282 PyObject *resultobj = 0;
27283 wxPyApp *arg1 = (wxPyApp *) 0 ;
27284 void *argp1 = 0 ;
27285 int res1 = 0 ;
27286 PyObject *swig_obj[1] ;
27287
27288 if (!args) SWIG_fail;
27289 swig_obj[0] = args;
27290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27291 if (!SWIG_IsOK(res1)) {
27292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27293 }
27294 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27295 {
27296 PyThreadState* __tstate = wxPyBeginAllowThreads();
27297 (arg1)->WakeUpIdle();
27298 wxPyEndAllowThreads(__tstate);
27299 if (PyErr_Occurred()) SWIG_fail;
27300 }
27301 resultobj = SWIG_Py_Void();
27302 return resultobj;
27303 fail:
27304 return NULL;
27305 }
27306
27307
27308 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27309 PyObject *resultobj = 0;
27310 bool result;
27311
27312 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27313 {
27314 PyThreadState* __tstate = wxPyBeginAllowThreads();
27315 result = (bool)wxPyApp::IsMainLoopRunning();
27316 wxPyEndAllowThreads(__tstate);
27317 if (PyErr_Occurred()) SWIG_fail;
27318 }
27319 {
27320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27321 }
27322 return resultobj;
27323 fail:
27324 return NULL;
27325 }
27326
27327
27328 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27329 PyObject *resultobj = 0;
27330 wxPyApp *arg1 = (wxPyApp *) 0 ;
27331 int result;
27332 void *argp1 = 0 ;
27333 int res1 = 0 ;
27334 PyObject *swig_obj[1] ;
27335
27336 if (!args) SWIG_fail;
27337 swig_obj[0] = args;
27338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27339 if (!SWIG_IsOK(res1)) {
27340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27341 }
27342 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27343 {
27344 PyThreadState* __tstate = wxPyBeginAllowThreads();
27345 result = (int)(arg1)->MainLoop();
27346 wxPyEndAllowThreads(__tstate);
27347 if (PyErr_Occurred()) SWIG_fail;
27348 }
27349 resultobj = SWIG_From_int(static_cast< int >(result));
27350 return resultobj;
27351 fail:
27352 return NULL;
27353 }
27354
27355
27356 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27357 PyObject *resultobj = 0;
27358 wxPyApp *arg1 = (wxPyApp *) 0 ;
27359 void *argp1 = 0 ;
27360 int res1 = 0 ;
27361 PyObject *swig_obj[1] ;
27362
27363 if (!args) SWIG_fail;
27364 swig_obj[0] = args;
27365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27366 if (!SWIG_IsOK(res1)) {
27367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27368 }
27369 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27370 {
27371 PyThreadState* __tstate = wxPyBeginAllowThreads();
27372 (arg1)->Exit();
27373 wxPyEndAllowThreads(__tstate);
27374 if (PyErr_Occurred()) SWIG_fail;
27375 }
27376 resultobj = SWIG_Py_Void();
27377 return resultobj;
27378 fail:
27379 return NULL;
27380 }
27381
27382
27383 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27384 PyObject *resultobj = 0;
27385 wxPyApp *arg1 = (wxPyApp *) 0 ;
27386 void *argp1 = 0 ;
27387 int res1 = 0 ;
27388 PyObject *swig_obj[1] ;
27389
27390 if (!args) SWIG_fail;
27391 swig_obj[0] = args;
27392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27393 if (!SWIG_IsOK(res1)) {
27394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27395 }
27396 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27397 {
27398 PyThreadState* __tstate = wxPyBeginAllowThreads();
27399 (arg1)->ExitMainLoop();
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 resultobj = SWIG_Py_Void();
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27411 PyObject *resultobj = 0;
27412 wxPyApp *arg1 = (wxPyApp *) 0 ;
27413 bool result;
27414 void *argp1 = 0 ;
27415 int res1 = 0 ;
27416 PyObject *swig_obj[1] ;
27417
27418 if (!args) SWIG_fail;
27419 swig_obj[0] = args;
27420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27421 if (!SWIG_IsOK(res1)) {
27422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27423 }
27424 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27425 {
27426 PyThreadState* __tstate = wxPyBeginAllowThreads();
27427 result = (bool)(arg1)->Pending();
27428 wxPyEndAllowThreads(__tstate);
27429 if (PyErr_Occurred()) SWIG_fail;
27430 }
27431 {
27432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27433 }
27434 return resultobj;
27435 fail:
27436 return NULL;
27437 }
27438
27439
27440 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27441 PyObject *resultobj = 0;
27442 wxPyApp *arg1 = (wxPyApp *) 0 ;
27443 bool result;
27444 void *argp1 = 0 ;
27445 int res1 = 0 ;
27446 PyObject *swig_obj[1] ;
27447
27448 if (!args) SWIG_fail;
27449 swig_obj[0] = args;
27450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27451 if (!SWIG_IsOK(res1)) {
27452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27453 }
27454 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27455 {
27456 PyThreadState* __tstate = wxPyBeginAllowThreads();
27457 result = (bool)(arg1)->Dispatch();
27458 wxPyEndAllowThreads(__tstate);
27459 if (PyErr_Occurred()) SWIG_fail;
27460 }
27461 {
27462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27463 }
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27471 PyObject *resultobj = 0;
27472 wxPyApp *arg1 = (wxPyApp *) 0 ;
27473 bool result;
27474 void *argp1 = 0 ;
27475 int res1 = 0 ;
27476 PyObject *swig_obj[1] ;
27477
27478 if (!args) SWIG_fail;
27479 swig_obj[0] = args;
27480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27481 if (!SWIG_IsOK(res1)) {
27482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27483 }
27484 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 result = (bool)(arg1)->ProcessIdle();
27488 wxPyEndAllowThreads(__tstate);
27489 if (PyErr_Occurred()) SWIG_fail;
27490 }
27491 {
27492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27493 }
27494 return resultobj;
27495 fail:
27496 return NULL;
27497 }
27498
27499
27500 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27501 PyObject *resultobj = 0;
27502 wxPyApp *arg1 = (wxPyApp *) 0 ;
27503 wxWindow *arg2 = (wxWindow *) 0 ;
27504 wxIdleEvent *arg3 = 0 ;
27505 bool result;
27506 void *argp1 = 0 ;
27507 int res1 = 0 ;
27508 void *argp2 = 0 ;
27509 int res2 = 0 ;
27510 void *argp3 = 0 ;
27511 int res3 = 0 ;
27512 PyObject * obj0 = 0 ;
27513 PyObject * obj1 = 0 ;
27514 PyObject * obj2 = 0 ;
27515 char * kwnames[] = {
27516 (char *) "self",(char *) "win",(char *) "event", NULL
27517 };
27518
27519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27521 if (!SWIG_IsOK(res1)) {
27522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27523 }
27524 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27525 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27526 if (!SWIG_IsOK(res2)) {
27527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27528 }
27529 arg2 = reinterpret_cast< wxWindow * >(argp2);
27530 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27531 if (!SWIG_IsOK(res3)) {
27532 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27533 }
27534 if (!argp3) {
27535 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27536 }
27537 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27538 {
27539 PyThreadState* __tstate = wxPyBeginAllowThreads();
27540 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27541 wxPyEndAllowThreads(__tstate);
27542 if (PyErr_Occurred()) SWIG_fail;
27543 }
27544 {
27545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27546 }
27547 return resultobj;
27548 fail:
27549 return NULL;
27550 }
27551
27552
27553 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27554 PyObject *resultobj = 0;
27555 wxPyApp *arg1 = (wxPyApp *) 0 ;
27556 bool result;
27557 void *argp1 = 0 ;
27558 int res1 = 0 ;
27559 PyObject *swig_obj[1] ;
27560
27561 if (!args) SWIG_fail;
27562 swig_obj[0] = args;
27563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27564 if (!SWIG_IsOK(res1)) {
27565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27566 }
27567 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27568 {
27569 PyThreadState* __tstate = wxPyBeginAllowThreads();
27570 result = (bool)((wxPyApp const *)arg1)->IsActive();
27571 wxPyEndAllowThreads(__tstate);
27572 if (PyErr_Occurred()) SWIG_fail;
27573 }
27574 {
27575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27576 }
27577 return resultobj;
27578 fail:
27579 return NULL;
27580 }
27581
27582
27583 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27584 PyObject *resultobj = 0;
27585 wxPyApp *arg1 = (wxPyApp *) 0 ;
27586 wxWindow *arg2 = (wxWindow *) 0 ;
27587 void *argp1 = 0 ;
27588 int res1 = 0 ;
27589 void *argp2 = 0 ;
27590 int res2 = 0 ;
27591 PyObject * obj0 = 0 ;
27592 PyObject * obj1 = 0 ;
27593 char * kwnames[] = {
27594 (char *) "self",(char *) "win", NULL
27595 };
27596
27597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27599 if (!SWIG_IsOK(res1)) {
27600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27601 }
27602 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27603 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27604 if (!SWIG_IsOK(res2)) {
27605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27606 }
27607 arg2 = reinterpret_cast< wxWindow * >(argp2);
27608 {
27609 PyThreadState* __tstate = wxPyBeginAllowThreads();
27610 (arg1)->SetTopWindow(arg2);
27611 wxPyEndAllowThreads(__tstate);
27612 if (PyErr_Occurred()) SWIG_fail;
27613 }
27614 resultobj = SWIG_Py_Void();
27615 return resultobj;
27616 fail:
27617 return NULL;
27618 }
27619
27620
27621 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27622 PyObject *resultobj = 0;
27623 wxPyApp *arg1 = (wxPyApp *) 0 ;
27624 wxWindow *result = 0 ;
27625 void *argp1 = 0 ;
27626 int res1 = 0 ;
27627 PyObject *swig_obj[1] ;
27628
27629 if (!args) SWIG_fail;
27630 swig_obj[0] = args;
27631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27632 if (!SWIG_IsOK(res1)) {
27633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27634 }
27635 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27636 {
27637 PyThreadState* __tstate = wxPyBeginAllowThreads();
27638 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 {
27643 resultobj = wxPyMake_wxObject(result, (bool)0);
27644 }
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27652 PyObject *resultobj = 0;
27653 wxPyApp *arg1 = (wxPyApp *) 0 ;
27654 bool arg2 ;
27655 void *argp1 = 0 ;
27656 int res1 = 0 ;
27657 bool val2 ;
27658 int ecode2 = 0 ;
27659 PyObject * obj0 = 0 ;
27660 PyObject * obj1 = 0 ;
27661 char * kwnames[] = {
27662 (char *) "self",(char *) "flag", NULL
27663 };
27664
27665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27667 if (!SWIG_IsOK(res1)) {
27668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27669 }
27670 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27671 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27672 if (!SWIG_IsOK(ecode2)) {
27673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27674 }
27675 arg2 = static_cast< bool >(val2);
27676 {
27677 PyThreadState* __tstate = wxPyBeginAllowThreads();
27678 (arg1)->SetExitOnFrameDelete(arg2);
27679 wxPyEndAllowThreads(__tstate);
27680 if (PyErr_Occurred()) SWIG_fail;
27681 }
27682 resultobj = SWIG_Py_Void();
27683 return resultobj;
27684 fail:
27685 return NULL;
27686 }
27687
27688
27689 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27690 PyObject *resultobj = 0;
27691 wxPyApp *arg1 = (wxPyApp *) 0 ;
27692 bool result;
27693 void *argp1 = 0 ;
27694 int res1 = 0 ;
27695 PyObject *swig_obj[1] ;
27696
27697 if (!args) SWIG_fail;
27698 swig_obj[0] = args;
27699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27700 if (!SWIG_IsOK(res1)) {
27701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27702 }
27703 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27704 {
27705 PyThreadState* __tstate = wxPyBeginAllowThreads();
27706 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27707 wxPyEndAllowThreads(__tstate);
27708 if (PyErr_Occurred()) SWIG_fail;
27709 }
27710 {
27711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27712 }
27713 return resultobj;
27714 fail:
27715 return NULL;
27716 }
27717
27718
27719 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27720 PyObject *resultobj = 0;
27721 wxPyApp *arg1 = (wxPyApp *) 0 ;
27722 bool arg2 ;
27723 void *argp1 = 0 ;
27724 int res1 = 0 ;
27725 bool val2 ;
27726 int ecode2 = 0 ;
27727 PyObject * obj0 = 0 ;
27728 PyObject * obj1 = 0 ;
27729 char * kwnames[] = {
27730 (char *) "self",(char *) "flag", NULL
27731 };
27732
27733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27735 if (!SWIG_IsOK(res1)) {
27736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27737 }
27738 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27739 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27740 if (!SWIG_IsOK(ecode2)) {
27741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27742 }
27743 arg2 = static_cast< bool >(val2);
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 (arg1)->SetUseBestVisual(arg2);
27747 wxPyEndAllowThreads(__tstate);
27748 if (PyErr_Occurred()) SWIG_fail;
27749 }
27750 resultobj = SWIG_Py_Void();
27751 return resultobj;
27752 fail:
27753 return NULL;
27754 }
27755
27756
27757 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27758 PyObject *resultobj = 0;
27759 wxPyApp *arg1 = (wxPyApp *) 0 ;
27760 bool result;
27761 void *argp1 = 0 ;
27762 int res1 = 0 ;
27763 PyObject *swig_obj[1] ;
27764
27765 if (!args) SWIG_fail;
27766 swig_obj[0] = args;
27767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27768 if (!SWIG_IsOK(res1)) {
27769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27770 }
27771 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27772 {
27773 PyThreadState* __tstate = wxPyBeginAllowThreads();
27774 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27775 wxPyEndAllowThreads(__tstate);
27776 if (PyErr_Occurred()) SWIG_fail;
27777 }
27778 {
27779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27780 }
27781 return resultobj;
27782 fail:
27783 return NULL;
27784 }
27785
27786
27787 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27788 PyObject *resultobj = 0;
27789 wxPyApp *arg1 = (wxPyApp *) 0 ;
27790 int arg2 ;
27791 void *argp1 = 0 ;
27792 int res1 = 0 ;
27793 int val2 ;
27794 int ecode2 = 0 ;
27795 PyObject * obj0 = 0 ;
27796 PyObject * obj1 = 0 ;
27797 char * kwnames[] = {
27798 (char *) "self",(char *) "mode", NULL
27799 };
27800
27801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27803 if (!SWIG_IsOK(res1)) {
27804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27805 }
27806 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27807 ecode2 = SWIG_AsVal_int(obj1, &val2);
27808 if (!SWIG_IsOK(ecode2)) {
27809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27810 }
27811 arg2 = static_cast< int >(val2);
27812 {
27813 PyThreadState* __tstate = wxPyBeginAllowThreads();
27814 (arg1)->SetPrintMode(arg2);
27815 wxPyEndAllowThreads(__tstate);
27816 if (PyErr_Occurred()) SWIG_fail;
27817 }
27818 resultobj = SWIG_Py_Void();
27819 return resultobj;
27820 fail:
27821 return NULL;
27822 }
27823
27824
27825 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27826 PyObject *resultobj = 0;
27827 wxPyApp *arg1 = (wxPyApp *) 0 ;
27828 int result;
27829 void *argp1 = 0 ;
27830 int res1 = 0 ;
27831 PyObject *swig_obj[1] ;
27832
27833 if (!args) SWIG_fail;
27834 swig_obj[0] = args;
27835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27836 if (!SWIG_IsOK(res1)) {
27837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27838 }
27839 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27840 {
27841 PyThreadState* __tstate = wxPyBeginAllowThreads();
27842 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27843 wxPyEndAllowThreads(__tstate);
27844 if (PyErr_Occurred()) SWIG_fail;
27845 }
27846 resultobj = SWIG_From_int(static_cast< int >(result));
27847 return resultobj;
27848 fail:
27849 return NULL;
27850 }
27851
27852
27853 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27854 PyObject *resultobj = 0;
27855 wxPyApp *arg1 = (wxPyApp *) 0 ;
27856 int arg2 ;
27857 void *argp1 = 0 ;
27858 int res1 = 0 ;
27859 int val2 ;
27860 int ecode2 = 0 ;
27861 PyObject * obj0 = 0 ;
27862 PyObject * obj1 = 0 ;
27863 char * kwnames[] = {
27864 (char *) "self",(char *) "mode", NULL
27865 };
27866
27867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27869 if (!SWIG_IsOK(res1)) {
27870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27871 }
27872 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27873 ecode2 = SWIG_AsVal_int(obj1, &val2);
27874 if (!SWIG_IsOK(ecode2)) {
27875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27876 }
27877 arg2 = static_cast< int >(val2);
27878 {
27879 PyThreadState* __tstate = wxPyBeginAllowThreads();
27880 (arg1)->SetAssertMode(arg2);
27881 wxPyEndAllowThreads(__tstate);
27882 if (PyErr_Occurred()) SWIG_fail;
27883 }
27884 resultobj = SWIG_Py_Void();
27885 return resultobj;
27886 fail:
27887 return NULL;
27888 }
27889
27890
27891 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27892 PyObject *resultobj = 0;
27893 wxPyApp *arg1 = (wxPyApp *) 0 ;
27894 int result;
27895 void *argp1 = 0 ;
27896 int res1 = 0 ;
27897 PyObject *swig_obj[1] ;
27898
27899 if (!args) SWIG_fail;
27900 swig_obj[0] = args;
27901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27902 if (!SWIG_IsOK(res1)) {
27903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27904 }
27905 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27906 {
27907 PyThreadState* __tstate = wxPyBeginAllowThreads();
27908 result = (int)(arg1)->GetAssertMode();
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 resultobj = SWIG_From_int(static_cast< int >(result));
27913 return resultobj;
27914 fail:
27915 return NULL;
27916 }
27917
27918
27919 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27920 PyObject *resultobj = 0;
27921 bool result;
27922
27923 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27924 {
27925 PyThreadState* __tstate = wxPyBeginAllowThreads();
27926 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27927 wxPyEndAllowThreads(__tstate);
27928 if (PyErr_Occurred()) SWIG_fail;
27929 }
27930 {
27931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27932 }
27933 return resultobj;
27934 fail:
27935 return NULL;
27936 }
27937
27938
27939 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27940 PyObject *resultobj = 0;
27941 long result;
27942
27943 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27944 {
27945 PyThreadState* __tstate = wxPyBeginAllowThreads();
27946 result = (long)wxPyApp::GetMacAboutMenuItemId();
27947 wxPyEndAllowThreads(__tstate);
27948 if (PyErr_Occurred()) SWIG_fail;
27949 }
27950 resultobj = SWIG_From_long(static_cast< long >(result));
27951 return resultobj;
27952 fail:
27953 return NULL;
27954 }
27955
27956
27957 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27958 PyObject *resultobj = 0;
27959 long result;
27960
27961 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27962 {
27963 PyThreadState* __tstate = wxPyBeginAllowThreads();
27964 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27965 wxPyEndAllowThreads(__tstate);
27966 if (PyErr_Occurred()) SWIG_fail;
27967 }
27968 resultobj = SWIG_From_long(static_cast< long >(result));
27969 return resultobj;
27970 fail:
27971 return NULL;
27972 }
27973
27974
27975 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27976 PyObject *resultobj = 0;
27977 long result;
27978
27979 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27980 {
27981 PyThreadState* __tstate = wxPyBeginAllowThreads();
27982 result = (long)wxPyApp::GetMacExitMenuItemId();
27983 wxPyEndAllowThreads(__tstate);
27984 if (PyErr_Occurred()) SWIG_fail;
27985 }
27986 resultobj = SWIG_From_long(static_cast< long >(result));
27987 return resultobj;
27988 fail:
27989 return NULL;
27990 }
27991
27992
27993 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27994 PyObject *resultobj = 0;
27995 wxString result;
27996
27997 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27998 {
27999 PyThreadState* __tstate = wxPyBeginAllowThreads();
28000 result = wxPyApp::GetMacHelpMenuTitleName();
28001 wxPyEndAllowThreads(__tstate);
28002 if (PyErr_Occurred()) SWIG_fail;
28003 }
28004 {
28005 #if wxUSE_UNICODE
28006 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28007 #else
28008 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28009 #endif
28010 }
28011 return resultobj;
28012 fail:
28013 return NULL;
28014 }
28015
28016
28017 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28018 PyObject *resultobj = 0;
28019 bool arg1 ;
28020 bool val1 ;
28021 int ecode1 = 0 ;
28022 PyObject * obj0 = 0 ;
28023 char * kwnames[] = {
28024 (char *) "val", NULL
28025 };
28026
28027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28028 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28029 if (!SWIG_IsOK(ecode1)) {
28030 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28031 }
28032 arg1 = static_cast< bool >(val1);
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28036 wxPyEndAllowThreads(__tstate);
28037 if (PyErr_Occurred()) SWIG_fail;
28038 }
28039 resultobj = SWIG_Py_Void();
28040 return resultobj;
28041 fail:
28042 return NULL;
28043 }
28044
28045
28046 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28047 PyObject *resultobj = 0;
28048 long arg1 ;
28049 long val1 ;
28050 int ecode1 = 0 ;
28051 PyObject * obj0 = 0 ;
28052 char * kwnames[] = {
28053 (char *) "val", NULL
28054 };
28055
28056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28057 ecode1 = SWIG_AsVal_long(obj0, &val1);
28058 if (!SWIG_IsOK(ecode1)) {
28059 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28060 }
28061 arg1 = static_cast< long >(val1);
28062 {
28063 PyThreadState* __tstate = wxPyBeginAllowThreads();
28064 wxPyApp::SetMacAboutMenuItemId(arg1);
28065 wxPyEndAllowThreads(__tstate);
28066 if (PyErr_Occurred()) SWIG_fail;
28067 }
28068 resultobj = SWIG_Py_Void();
28069 return resultobj;
28070 fail:
28071 return NULL;
28072 }
28073
28074
28075 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28076 PyObject *resultobj = 0;
28077 long arg1 ;
28078 long val1 ;
28079 int ecode1 = 0 ;
28080 PyObject * obj0 = 0 ;
28081 char * kwnames[] = {
28082 (char *) "val", NULL
28083 };
28084
28085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28086 ecode1 = SWIG_AsVal_long(obj0, &val1);
28087 if (!SWIG_IsOK(ecode1)) {
28088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28089 }
28090 arg1 = static_cast< long >(val1);
28091 {
28092 PyThreadState* __tstate = wxPyBeginAllowThreads();
28093 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28094 wxPyEndAllowThreads(__tstate);
28095 if (PyErr_Occurred()) SWIG_fail;
28096 }
28097 resultobj = SWIG_Py_Void();
28098 return resultobj;
28099 fail:
28100 return NULL;
28101 }
28102
28103
28104 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28105 PyObject *resultobj = 0;
28106 long arg1 ;
28107 long val1 ;
28108 int ecode1 = 0 ;
28109 PyObject * obj0 = 0 ;
28110 char * kwnames[] = {
28111 (char *) "val", NULL
28112 };
28113
28114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28115 ecode1 = SWIG_AsVal_long(obj0, &val1);
28116 if (!SWIG_IsOK(ecode1)) {
28117 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28118 }
28119 arg1 = static_cast< long >(val1);
28120 {
28121 PyThreadState* __tstate = wxPyBeginAllowThreads();
28122 wxPyApp::SetMacExitMenuItemId(arg1);
28123 wxPyEndAllowThreads(__tstate);
28124 if (PyErr_Occurred()) SWIG_fail;
28125 }
28126 resultobj = SWIG_Py_Void();
28127 return resultobj;
28128 fail:
28129 return NULL;
28130 }
28131
28132
28133 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28134 PyObject *resultobj = 0;
28135 wxString *arg1 = 0 ;
28136 bool temp1 = false ;
28137 PyObject * obj0 = 0 ;
28138 char * kwnames[] = {
28139 (char *) "val", NULL
28140 };
28141
28142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28143 {
28144 arg1 = wxString_in_helper(obj0);
28145 if (arg1 == NULL) SWIG_fail;
28146 temp1 = true;
28147 }
28148 {
28149 PyThreadState* __tstate = wxPyBeginAllowThreads();
28150 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28151 wxPyEndAllowThreads(__tstate);
28152 if (PyErr_Occurred()) SWIG_fail;
28153 }
28154 resultobj = SWIG_Py_Void();
28155 {
28156 if (temp1)
28157 delete arg1;
28158 }
28159 return resultobj;
28160 fail:
28161 {
28162 if (temp1)
28163 delete arg1;
28164 }
28165 return NULL;
28166 }
28167
28168
28169 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28170 PyObject *resultobj = 0;
28171 wxPyApp *arg1 = (wxPyApp *) 0 ;
28172 void *argp1 = 0 ;
28173 int res1 = 0 ;
28174 PyObject *swig_obj[1] ;
28175
28176 if (!args) SWIG_fail;
28177 swig_obj[0] = args;
28178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28179 if (!SWIG_IsOK(res1)) {
28180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28181 }
28182 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28183 {
28184 PyThreadState* __tstate = wxPyBeginAllowThreads();
28185 (arg1)->_BootstrapApp();
28186 wxPyEndAllowThreads(__tstate);
28187 if (PyErr_Occurred()) SWIG_fail;
28188 }
28189 resultobj = SWIG_Py_Void();
28190 return resultobj;
28191 fail:
28192 return NULL;
28193 }
28194
28195
28196 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28197 PyObject *resultobj = 0;
28198 int result;
28199
28200 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28201 {
28202 PyThreadState* __tstate = wxPyBeginAllowThreads();
28203 result = (int)wxPyApp_GetComCtl32Version();
28204 wxPyEndAllowThreads(__tstate);
28205 if (PyErr_Occurred()) SWIG_fail;
28206 }
28207 resultobj = SWIG_From_int(static_cast< int >(result));
28208 return resultobj;
28209 fail:
28210 return NULL;
28211 }
28212
28213
28214 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28215 PyObject *obj;
28216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28217 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28218 return SWIG_Py_Void();
28219 }
28220
28221 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28222 return SWIG_Python_InitShadowInstance(args);
28223 }
28224
28225 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28226 PyObject *resultobj = 0;
28227
28228 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28229 {
28230 PyThreadState* __tstate = wxPyBeginAllowThreads();
28231 wxExit();
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 resultobj = SWIG_Py_Void();
28236 return resultobj;
28237 fail:
28238 return NULL;
28239 }
28240
28241
28242 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28243 PyObject *resultobj = 0;
28244 bool result;
28245
28246 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28247 {
28248 PyThreadState* __tstate = wxPyBeginAllowThreads();
28249 result = (bool)wxYield();
28250 wxPyEndAllowThreads(__tstate);
28251 if (PyErr_Occurred()) SWIG_fail;
28252 }
28253 {
28254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28255 }
28256 return resultobj;
28257 fail:
28258 return NULL;
28259 }
28260
28261
28262 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28263 PyObject *resultobj = 0;
28264 bool result;
28265
28266 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28267 {
28268 PyThreadState* __tstate = wxPyBeginAllowThreads();
28269 result = (bool)wxYieldIfNeeded();
28270 wxPyEndAllowThreads(__tstate);
28271 if (PyErr_Occurred()) SWIG_fail;
28272 }
28273 {
28274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28275 }
28276 return resultobj;
28277 fail:
28278 return NULL;
28279 }
28280
28281
28282 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28283 PyObject *resultobj = 0;
28284 wxWindow *arg1 = (wxWindow *) NULL ;
28285 bool arg2 = (bool) false ;
28286 bool result;
28287 void *argp1 = 0 ;
28288 int res1 = 0 ;
28289 bool val2 ;
28290 int ecode2 = 0 ;
28291 PyObject * obj0 = 0 ;
28292 PyObject * obj1 = 0 ;
28293 char * kwnames[] = {
28294 (char *) "win",(char *) "onlyIfNeeded", NULL
28295 };
28296
28297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28298 if (obj0) {
28299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28300 if (!SWIG_IsOK(res1)) {
28301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28302 }
28303 arg1 = reinterpret_cast< wxWindow * >(argp1);
28304 }
28305 if (obj1) {
28306 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28307 if (!SWIG_IsOK(ecode2)) {
28308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28309 }
28310 arg2 = static_cast< bool >(val2);
28311 }
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 result = (bool)wxSafeYield(arg1,arg2);
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 {
28319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28320 }
28321 return resultobj;
28322 fail:
28323 return NULL;
28324 }
28325
28326
28327 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28328 PyObject *resultobj = 0;
28329
28330 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28331 {
28332 PyThreadState* __tstate = wxPyBeginAllowThreads();
28333 wxWakeUpIdle();
28334 wxPyEndAllowThreads(__tstate);
28335 if (PyErr_Occurred()) SWIG_fail;
28336 }
28337 resultobj = SWIG_Py_Void();
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28345 PyObject *resultobj = 0;
28346 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28347 wxEvent *arg2 = 0 ;
28348 void *argp1 = 0 ;
28349 int res1 = 0 ;
28350 void *argp2 = 0 ;
28351 int res2 = 0 ;
28352 PyObject * obj0 = 0 ;
28353 PyObject * obj1 = 0 ;
28354 char * kwnames[] = {
28355 (char *) "dest",(char *) "event", NULL
28356 };
28357
28358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28360 if (!SWIG_IsOK(res1)) {
28361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28362 }
28363 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28365 if (!SWIG_IsOK(res2)) {
28366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28367 }
28368 if (!argp2) {
28369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28370 }
28371 arg2 = reinterpret_cast< wxEvent * >(argp2);
28372 {
28373 PyThreadState* __tstate = wxPyBeginAllowThreads();
28374 wxPostEvent(arg1,*arg2);
28375 wxPyEndAllowThreads(__tstate);
28376 if (PyErr_Occurred()) SWIG_fail;
28377 }
28378 resultobj = SWIG_Py_Void();
28379 return resultobj;
28380 fail:
28381 return NULL;
28382 }
28383
28384
28385 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28386 PyObject *resultobj = 0;
28387
28388 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28389 {
28390 PyThreadState* __tstate = wxPyBeginAllowThreads();
28391 wxApp_CleanUp();
28392 wxPyEndAllowThreads(__tstate);
28393 if (PyErr_Occurred()) SWIG_fail;
28394 }
28395 resultobj = SWIG_Py_Void();
28396 return resultobj;
28397 fail:
28398 return NULL;
28399 }
28400
28401
28402 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28403 PyObject *resultobj = 0;
28404 wxPyApp *result = 0 ;
28405
28406 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28407 {
28408 PyThreadState* __tstate = wxPyBeginAllowThreads();
28409 result = (wxPyApp *)wxPyGetApp();
28410 wxPyEndAllowThreads(__tstate);
28411 if (PyErr_Occurred()) SWIG_fail;
28412 }
28413 {
28414 resultobj = wxPyMake_wxObject(result, 0);
28415 }
28416 return resultobj;
28417 fail:
28418 return NULL;
28419 }
28420
28421
28422 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28423 PyObject *resultobj = 0;
28424 char *arg1 = (char *) 0 ;
28425 int res1 ;
28426 char *buf1 = 0 ;
28427 int alloc1 = 0 ;
28428 PyObject * obj0 = 0 ;
28429 char * kwnames[] = {
28430 (char *) "encoding", NULL
28431 };
28432
28433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28434 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28435 if (!SWIG_IsOK(res1)) {
28436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28437 }
28438 arg1 = buf1;
28439 {
28440 PyThreadState* __tstate = wxPyBeginAllowThreads();
28441 wxSetDefaultPyEncoding((char const *)arg1);
28442 wxPyEndAllowThreads(__tstate);
28443 if (PyErr_Occurred()) SWIG_fail;
28444 }
28445 resultobj = SWIG_Py_Void();
28446 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28447 return resultobj;
28448 fail:
28449 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28450 return NULL;
28451 }
28452
28453
28454 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28455 PyObject *resultobj = 0;
28456 char *result = 0 ;
28457
28458 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28459 {
28460 PyThreadState* __tstate = wxPyBeginAllowThreads();
28461 result = (char *)wxGetDefaultPyEncoding();
28462 wxPyEndAllowThreads(__tstate);
28463 if (PyErr_Occurred()) SWIG_fail;
28464 }
28465 resultobj = SWIG_FromCharPtr(result);
28466 return resultobj;
28467 fail:
28468 return NULL;
28469 }
28470
28471
28472 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28473 PyObject *resultobj = 0;
28474 wxEventLoop *result = 0 ;
28475
28476 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28477 {
28478 PyThreadState* __tstate = wxPyBeginAllowThreads();
28479 result = (wxEventLoop *)new wxEventLoop();
28480 wxPyEndAllowThreads(__tstate);
28481 if (PyErr_Occurred()) SWIG_fail;
28482 }
28483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28484 return resultobj;
28485 fail:
28486 return NULL;
28487 }
28488
28489
28490 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28491 PyObject *resultobj = 0;
28492 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28493 void *argp1 = 0 ;
28494 int res1 = 0 ;
28495 PyObject *swig_obj[1] ;
28496
28497 if (!args) SWIG_fail;
28498 swig_obj[0] = args;
28499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28500 if (!SWIG_IsOK(res1)) {
28501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28502 }
28503 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28504 {
28505 PyThreadState* __tstate = wxPyBeginAllowThreads();
28506 delete arg1;
28507
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 resultobj = SWIG_Py_Void();
28512 return resultobj;
28513 fail:
28514 return NULL;
28515 }
28516
28517
28518 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28519 PyObject *resultobj = 0;
28520 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28521 int result;
28522 void *argp1 = 0 ;
28523 int res1 = 0 ;
28524 PyObject *swig_obj[1] ;
28525
28526 if (!args) SWIG_fail;
28527 swig_obj[0] = args;
28528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28529 if (!SWIG_IsOK(res1)) {
28530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28531 }
28532 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28533 {
28534 PyThreadState* __tstate = wxPyBeginAllowThreads();
28535 result = (int)(arg1)->Run();
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 resultobj = SWIG_From_int(static_cast< int >(result));
28540 return resultobj;
28541 fail:
28542 return NULL;
28543 }
28544
28545
28546 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28547 PyObject *resultobj = 0;
28548 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28549 int arg2 = (int) 0 ;
28550 void *argp1 = 0 ;
28551 int res1 = 0 ;
28552 int val2 ;
28553 int ecode2 = 0 ;
28554 PyObject * obj0 = 0 ;
28555 PyObject * obj1 = 0 ;
28556 char * kwnames[] = {
28557 (char *) "self",(char *) "rc", NULL
28558 };
28559
28560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28562 if (!SWIG_IsOK(res1)) {
28563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28564 }
28565 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28566 if (obj1) {
28567 ecode2 = SWIG_AsVal_int(obj1, &val2);
28568 if (!SWIG_IsOK(ecode2)) {
28569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28570 }
28571 arg2 = static_cast< int >(val2);
28572 }
28573 {
28574 PyThreadState* __tstate = wxPyBeginAllowThreads();
28575 (arg1)->Exit(arg2);
28576 wxPyEndAllowThreads(__tstate);
28577 if (PyErr_Occurred()) SWIG_fail;
28578 }
28579 resultobj = SWIG_Py_Void();
28580 return resultobj;
28581 fail:
28582 return NULL;
28583 }
28584
28585
28586 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28587 PyObject *resultobj = 0;
28588 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28589 bool result;
28590 void *argp1 = 0 ;
28591 int res1 = 0 ;
28592 PyObject *swig_obj[1] ;
28593
28594 if (!args) SWIG_fail;
28595 swig_obj[0] = args;
28596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28597 if (!SWIG_IsOK(res1)) {
28598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28599 }
28600 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28601 {
28602 PyThreadState* __tstate = wxPyBeginAllowThreads();
28603 result = (bool)((wxEventLoop const *)arg1)->Pending();
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 {
28608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28609 }
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28617 PyObject *resultobj = 0;
28618 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28619 bool result;
28620 void *argp1 = 0 ;
28621 int res1 = 0 ;
28622 PyObject *swig_obj[1] ;
28623
28624 if (!args) SWIG_fail;
28625 swig_obj[0] = args;
28626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28627 if (!SWIG_IsOK(res1)) {
28628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28629 }
28630 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28631 {
28632 PyThreadState* __tstate = wxPyBeginAllowThreads();
28633 result = (bool)(arg1)->Dispatch();
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 {
28638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28639 }
28640 return resultobj;
28641 fail:
28642 return NULL;
28643 }
28644
28645
28646 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28647 PyObject *resultobj = 0;
28648 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28649 bool result;
28650 void *argp1 = 0 ;
28651 int res1 = 0 ;
28652 PyObject *swig_obj[1] ;
28653
28654 if (!args) SWIG_fail;
28655 swig_obj[0] = args;
28656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28657 if (!SWIG_IsOK(res1)) {
28658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28659 }
28660 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28661 {
28662 PyThreadState* __tstate = wxPyBeginAllowThreads();
28663 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28664 wxPyEndAllowThreads(__tstate);
28665 if (PyErr_Occurred()) SWIG_fail;
28666 }
28667 {
28668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28669 }
28670 return resultobj;
28671 fail:
28672 return NULL;
28673 }
28674
28675
28676 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28677 PyObject *resultobj = 0;
28678 wxEventLoop *result = 0 ;
28679
28680 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28681 {
28682 PyThreadState* __tstate = wxPyBeginAllowThreads();
28683 result = (wxEventLoop *)wxEventLoop::GetActive();
28684 wxPyEndAllowThreads(__tstate);
28685 if (PyErr_Occurred()) SWIG_fail;
28686 }
28687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28688 return resultobj;
28689 fail:
28690 return NULL;
28691 }
28692
28693
28694 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28695 PyObject *resultobj = 0;
28696 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28697 void *argp1 = 0 ;
28698 int res1 = 0 ;
28699 PyObject * obj0 = 0 ;
28700 char * kwnames[] = {
28701 (char *) "loop", NULL
28702 };
28703
28704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28706 if (!SWIG_IsOK(res1)) {
28707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28708 }
28709 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28710 {
28711 PyThreadState* __tstate = wxPyBeginAllowThreads();
28712 wxEventLoop::SetActive(arg1);
28713 wxPyEndAllowThreads(__tstate);
28714 if (PyErr_Occurred()) SWIG_fail;
28715 }
28716 resultobj = SWIG_Py_Void();
28717 return resultobj;
28718 fail:
28719 return NULL;
28720 }
28721
28722
28723 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28724 PyObject *obj;
28725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28726 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28727 return SWIG_Py_Void();
28728 }
28729
28730 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28731 return SWIG_Python_InitShadowInstance(args);
28732 }
28733
28734 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28735 PyObject *resultobj = 0;
28736 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28737 wxEventLoopActivator *result = 0 ;
28738 void *argp1 = 0 ;
28739 int res1 = 0 ;
28740 PyObject * obj0 = 0 ;
28741 char * kwnames[] = {
28742 (char *) "evtLoop", NULL
28743 };
28744
28745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28747 if (!SWIG_IsOK(res1)) {
28748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28749 }
28750 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28751 {
28752 PyThreadState* __tstate = wxPyBeginAllowThreads();
28753 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28765 PyObject *resultobj = 0;
28766 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28767 void *argp1 = 0 ;
28768 int res1 = 0 ;
28769 PyObject *swig_obj[1] ;
28770
28771 if (!args) SWIG_fail;
28772 swig_obj[0] = args;
28773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28774 if (!SWIG_IsOK(res1)) {
28775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28776 }
28777 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28778 {
28779 PyThreadState* __tstate = wxPyBeginAllowThreads();
28780 delete arg1;
28781
28782 wxPyEndAllowThreads(__tstate);
28783 if (PyErr_Occurred()) SWIG_fail;
28784 }
28785 resultobj = SWIG_Py_Void();
28786 return resultobj;
28787 fail:
28788 return NULL;
28789 }
28790
28791
28792 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28793 PyObject *obj;
28794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28795 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28796 return SWIG_Py_Void();
28797 }
28798
28799 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28800 return SWIG_Python_InitShadowInstance(args);
28801 }
28802
28803 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28804 PyObject *resultobj = 0;
28805 int arg1 = (int) 0 ;
28806 int arg2 = (int) 0 ;
28807 int arg3 = (int) 0 ;
28808 wxAcceleratorEntry *result = 0 ;
28809 int val1 ;
28810 int ecode1 = 0 ;
28811 int val2 ;
28812 int ecode2 = 0 ;
28813 int val3 ;
28814 int ecode3 = 0 ;
28815 PyObject * obj0 = 0 ;
28816 PyObject * obj1 = 0 ;
28817 PyObject * obj2 = 0 ;
28818 char * kwnames[] = {
28819 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28820 };
28821
28822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28823 if (obj0) {
28824 ecode1 = SWIG_AsVal_int(obj0, &val1);
28825 if (!SWIG_IsOK(ecode1)) {
28826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28827 }
28828 arg1 = static_cast< int >(val1);
28829 }
28830 if (obj1) {
28831 ecode2 = SWIG_AsVal_int(obj1, &val2);
28832 if (!SWIG_IsOK(ecode2)) {
28833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28834 }
28835 arg2 = static_cast< int >(val2);
28836 }
28837 if (obj2) {
28838 ecode3 = SWIG_AsVal_int(obj2, &val3);
28839 if (!SWIG_IsOK(ecode3)) {
28840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28841 }
28842 arg3 = static_cast< int >(val3);
28843 }
28844 {
28845 PyThreadState* __tstate = wxPyBeginAllowThreads();
28846 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28847 wxPyEndAllowThreads(__tstate);
28848 if (PyErr_Occurred()) SWIG_fail;
28849 }
28850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28851 return resultobj;
28852 fail:
28853 return NULL;
28854 }
28855
28856
28857 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28858 PyObject *resultobj = 0;
28859 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28860 void *argp1 = 0 ;
28861 int res1 = 0 ;
28862 PyObject *swig_obj[1] ;
28863
28864 if (!args) SWIG_fail;
28865 swig_obj[0] = args;
28866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28867 if (!SWIG_IsOK(res1)) {
28868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28869 }
28870 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28871 {
28872 PyThreadState* __tstate = wxPyBeginAllowThreads();
28873 delete arg1;
28874
28875 wxPyEndAllowThreads(__tstate);
28876 if (PyErr_Occurred()) SWIG_fail;
28877 }
28878 resultobj = SWIG_Py_Void();
28879 return resultobj;
28880 fail:
28881 return NULL;
28882 }
28883
28884
28885 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28886 PyObject *resultobj = 0;
28887 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28888 int arg2 ;
28889 int arg3 ;
28890 int arg4 ;
28891 void *argp1 = 0 ;
28892 int res1 = 0 ;
28893 int val2 ;
28894 int ecode2 = 0 ;
28895 int val3 ;
28896 int ecode3 = 0 ;
28897 int val4 ;
28898 int ecode4 = 0 ;
28899 PyObject * obj0 = 0 ;
28900 PyObject * obj1 = 0 ;
28901 PyObject * obj2 = 0 ;
28902 PyObject * obj3 = 0 ;
28903 char * kwnames[] = {
28904 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28905 };
28906
28907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28909 if (!SWIG_IsOK(res1)) {
28910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28911 }
28912 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28913 ecode2 = SWIG_AsVal_int(obj1, &val2);
28914 if (!SWIG_IsOK(ecode2)) {
28915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28916 }
28917 arg2 = static_cast< int >(val2);
28918 ecode3 = SWIG_AsVal_int(obj2, &val3);
28919 if (!SWIG_IsOK(ecode3)) {
28920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28921 }
28922 arg3 = static_cast< int >(val3);
28923 ecode4 = SWIG_AsVal_int(obj3, &val4);
28924 if (!SWIG_IsOK(ecode4)) {
28925 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28926 }
28927 arg4 = static_cast< int >(val4);
28928 {
28929 PyThreadState* __tstate = wxPyBeginAllowThreads();
28930 (arg1)->Set(arg2,arg3,arg4);
28931 wxPyEndAllowThreads(__tstate);
28932 if (PyErr_Occurred()) SWIG_fail;
28933 }
28934 resultobj = SWIG_Py_Void();
28935 return resultobj;
28936 fail:
28937 return NULL;
28938 }
28939
28940
28941 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28942 PyObject *resultobj = 0;
28943 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28944 int result;
28945 void *argp1 = 0 ;
28946 int res1 = 0 ;
28947 PyObject *swig_obj[1] ;
28948
28949 if (!args) SWIG_fail;
28950 swig_obj[0] = args;
28951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28952 if (!SWIG_IsOK(res1)) {
28953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28954 }
28955 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28956 {
28957 PyThreadState* __tstate = wxPyBeginAllowThreads();
28958 result = (int)(arg1)->GetFlags();
28959 wxPyEndAllowThreads(__tstate);
28960 if (PyErr_Occurred()) SWIG_fail;
28961 }
28962 resultobj = SWIG_From_int(static_cast< int >(result));
28963 return resultobj;
28964 fail:
28965 return NULL;
28966 }
28967
28968
28969 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28970 PyObject *resultobj = 0;
28971 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28972 int 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_wxAcceleratorEntry, 0 | 0 );
28980 if (!SWIG_IsOK(res1)) {
28981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28982 }
28983 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = (int)(arg1)->GetKeyCode();
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 resultobj = SWIG_From_int(static_cast< int >(result));
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28998 PyObject *resultobj = 0;
28999 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29000 int result;
29001 void *argp1 = 0 ;
29002 int res1 = 0 ;
29003 PyObject *swig_obj[1] ;
29004
29005 if (!args) SWIG_fail;
29006 swig_obj[0] = args;
29007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29008 if (!SWIG_IsOK(res1)) {
29009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29010 }
29011 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29012 {
29013 PyThreadState* __tstate = wxPyBeginAllowThreads();
29014 result = (int)(arg1)->GetCommand();
29015 wxPyEndAllowThreads(__tstate);
29016 if (PyErr_Occurred()) SWIG_fail;
29017 }
29018 resultobj = SWIG_From_int(static_cast< int >(result));
29019 return resultobj;
29020 fail:
29021 return NULL;
29022 }
29023
29024
29025 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29026 PyObject *obj;
29027 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29028 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29029 return SWIG_Py_Void();
29030 }
29031
29032 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29033 return SWIG_Python_InitShadowInstance(args);
29034 }
29035
29036 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29037 PyObject *resultobj = 0;
29038 int arg1 ;
29039 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29040 wxAcceleratorTable *result = 0 ;
29041 PyObject * obj0 = 0 ;
29042 char * kwnames[] = {
29043 (char *) "n", NULL
29044 };
29045
29046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29047 {
29048 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29049 if (arg2) arg1 = PyList_Size(obj0);
29050 else arg1 = 0;
29051 }
29052 {
29053 PyThreadState* __tstate = wxPyBeginAllowThreads();
29054 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29055 wxPyEndAllowThreads(__tstate);
29056 if (PyErr_Occurred()) SWIG_fail;
29057 }
29058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29059 return resultobj;
29060 fail:
29061 return NULL;
29062 }
29063
29064
29065 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29066 PyObject *resultobj = 0;
29067 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29068 void *argp1 = 0 ;
29069 int res1 = 0 ;
29070 PyObject *swig_obj[1] ;
29071
29072 if (!args) SWIG_fail;
29073 swig_obj[0] = args;
29074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29075 if (!SWIG_IsOK(res1)) {
29076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29077 }
29078 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29079 {
29080 PyThreadState* __tstate = wxPyBeginAllowThreads();
29081 delete arg1;
29082
29083 wxPyEndAllowThreads(__tstate);
29084 if (PyErr_Occurred()) SWIG_fail;
29085 }
29086 resultobj = SWIG_Py_Void();
29087 return resultobj;
29088 fail:
29089 return NULL;
29090 }
29091
29092
29093 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29094 PyObject *resultobj = 0;
29095 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29096 bool result;
29097 void *argp1 = 0 ;
29098 int res1 = 0 ;
29099 PyObject *swig_obj[1] ;
29100
29101 if (!args) SWIG_fail;
29102 swig_obj[0] = args;
29103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29104 if (!SWIG_IsOK(res1)) {
29105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29106 }
29107 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29108 {
29109 PyThreadState* __tstate = wxPyBeginAllowThreads();
29110 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 {
29115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29116 }
29117 return resultobj;
29118 fail:
29119 return NULL;
29120 }
29121
29122
29123 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29124 PyObject *obj;
29125 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29126 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29127 return SWIG_Py_Void();
29128 }
29129
29130 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29131 return SWIG_Python_InitShadowInstance(args);
29132 }
29133
29134 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29135 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29136 return 1;
29137 }
29138
29139
29140 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29141 PyObject *pyobj = 0;
29142
29143 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29144 return pyobj;
29145 }
29146
29147
29148 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29149 PyObject *resultobj = 0;
29150 wxString *arg1 = 0 ;
29151 wxAcceleratorEntry *result = 0 ;
29152 bool temp1 = false ;
29153 PyObject * obj0 = 0 ;
29154 char * kwnames[] = {
29155 (char *) "label", NULL
29156 };
29157
29158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29159 {
29160 arg1 = wxString_in_helper(obj0);
29161 if (arg1 == NULL) SWIG_fail;
29162 temp1 = true;
29163 }
29164 {
29165 PyThreadState* __tstate = wxPyBeginAllowThreads();
29166 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29167 wxPyEndAllowThreads(__tstate);
29168 if (PyErr_Occurred()) SWIG_fail;
29169 }
29170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29171 {
29172 if (temp1)
29173 delete arg1;
29174 }
29175 return resultobj;
29176 fail:
29177 {
29178 if (temp1)
29179 delete arg1;
29180 }
29181 return NULL;
29182 }
29183
29184
29185 SWIGINTERN int PanelNameStr_set(PyObject *) {
29186 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29187 return 1;
29188 }
29189
29190
29191 SWIGINTERN PyObject *PanelNameStr_get(void) {
29192 PyObject *pyobj = 0;
29193
29194 {
29195 #if wxUSE_UNICODE
29196 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29197 #else
29198 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29199 #endif
29200 }
29201 return pyobj;
29202 }
29203
29204
29205 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29206 PyObject *resultobj = 0;
29207 wxVisualAttributes *result = 0 ;
29208
29209 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29210 {
29211 PyThreadState* __tstate = wxPyBeginAllowThreads();
29212 result = (wxVisualAttributes *)new_wxVisualAttributes();
29213 wxPyEndAllowThreads(__tstate);
29214 if (PyErr_Occurred()) SWIG_fail;
29215 }
29216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29217 return resultobj;
29218 fail:
29219 return NULL;
29220 }
29221
29222
29223 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29224 PyObject *resultobj = 0;
29225 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29226 void *argp1 = 0 ;
29227 int res1 = 0 ;
29228 PyObject *swig_obj[1] ;
29229
29230 if (!args) SWIG_fail;
29231 swig_obj[0] = args;
29232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29233 if (!SWIG_IsOK(res1)) {
29234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29235 }
29236 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29237 {
29238 PyThreadState* __tstate = wxPyBeginAllowThreads();
29239 delete_wxVisualAttributes(arg1);
29240
29241 wxPyEndAllowThreads(__tstate);
29242 if (PyErr_Occurred()) SWIG_fail;
29243 }
29244 resultobj = SWIG_Py_Void();
29245 return resultobj;
29246 fail:
29247 return NULL;
29248 }
29249
29250
29251 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29252 PyObject *resultobj = 0;
29253 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29254 wxFont *arg2 = (wxFont *) 0 ;
29255 void *argp1 = 0 ;
29256 int res1 = 0 ;
29257 void *argp2 = 0 ;
29258 int res2 = 0 ;
29259 PyObject *swig_obj[2] ;
29260
29261 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29263 if (!SWIG_IsOK(res1)) {
29264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29265 }
29266 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29267 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29268 if (!SWIG_IsOK(res2)) {
29269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29270 }
29271 arg2 = reinterpret_cast< wxFont * >(argp2);
29272 if (arg1) (arg1)->font = *arg2;
29273
29274 resultobj = SWIG_Py_Void();
29275 return resultobj;
29276 fail:
29277 return NULL;
29278 }
29279
29280
29281 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29282 PyObject *resultobj = 0;
29283 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29284 wxFont *result = 0 ;
29285 void *argp1 = 0 ;
29286 int res1 = 0 ;
29287 PyObject *swig_obj[1] ;
29288
29289 if (!args) SWIG_fail;
29290 swig_obj[0] = args;
29291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29292 if (!SWIG_IsOK(res1)) {
29293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29294 }
29295 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29296 result = (wxFont *)& ((arg1)->font);
29297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29298 return resultobj;
29299 fail:
29300 return NULL;
29301 }
29302
29303
29304 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29305 PyObject *resultobj = 0;
29306 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29307 wxColour *arg2 = (wxColour *) 0 ;
29308 void *argp1 = 0 ;
29309 int res1 = 0 ;
29310 void *argp2 = 0 ;
29311 int res2 = 0 ;
29312 PyObject *swig_obj[2] ;
29313
29314 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29316 if (!SWIG_IsOK(res1)) {
29317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29318 }
29319 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29320 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29321 if (!SWIG_IsOK(res2)) {
29322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29323 }
29324 arg2 = reinterpret_cast< wxColour * >(argp2);
29325 if (arg1) (arg1)->colFg = *arg2;
29326
29327 resultobj = SWIG_Py_Void();
29328 return resultobj;
29329 fail:
29330 return NULL;
29331 }
29332
29333
29334 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29335 PyObject *resultobj = 0;
29336 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29337 wxColour *result = 0 ;
29338 void *argp1 = 0 ;
29339 int res1 = 0 ;
29340 PyObject *swig_obj[1] ;
29341
29342 if (!args) SWIG_fail;
29343 swig_obj[0] = args;
29344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29345 if (!SWIG_IsOK(res1)) {
29346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29347 }
29348 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29349 result = (wxColour *)& ((arg1)->colFg);
29350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29351 return resultobj;
29352 fail:
29353 return NULL;
29354 }
29355
29356
29357 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29358 PyObject *resultobj = 0;
29359 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29360 wxColour *arg2 = (wxColour *) 0 ;
29361 void *argp1 = 0 ;
29362 int res1 = 0 ;
29363 void *argp2 = 0 ;
29364 int res2 = 0 ;
29365 PyObject *swig_obj[2] ;
29366
29367 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29369 if (!SWIG_IsOK(res1)) {
29370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29371 }
29372 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29373 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29374 if (!SWIG_IsOK(res2)) {
29375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29376 }
29377 arg2 = reinterpret_cast< wxColour * >(argp2);
29378 if (arg1) (arg1)->colBg = *arg2;
29379
29380 resultobj = SWIG_Py_Void();
29381 return resultobj;
29382 fail:
29383 return NULL;
29384 }
29385
29386
29387 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29388 PyObject *resultobj = 0;
29389 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29390 wxColour *result = 0 ;
29391 void *argp1 = 0 ;
29392 int res1 = 0 ;
29393 PyObject *swig_obj[1] ;
29394
29395 if (!args) SWIG_fail;
29396 swig_obj[0] = args;
29397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29398 if (!SWIG_IsOK(res1)) {
29399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29400 }
29401 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29402 result = (wxColour *)& ((arg1)->colBg);
29403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29404 return resultobj;
29405 fail:
29406 return NULL;
29407 }
29408
29409
29410 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29411 PyObject *obj;
29412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29413 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29414 return SWIG_Py_Void();
29415 }
29416
29417 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29418 return SWIG_Python_InitShadowInstance(args);
29419 }
29420
29421 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29422 PyObject *resultobj = 0;
29423 wxWindow *arg1 = (wxWindow *) 0 ;
29424 int arg2 = (int) (int)-1 ;
29425 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29426 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29427 wxSize const &arg4_defvalue = wxDefaultSize ;
29428 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29429 long arg5 = (long) 0 ;
29430 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29431 wxString *arg6 = (wxString *) &arg6_defvalue ;
29432 wxWindow *result = 0 ;
29433 void *argp1 = 0 ;
29434 int res1 = 0 ;
29435 int val2 ;
29436 int ecode2 = 0 ;
29437 wxPoint temp3 ;
29438 wxSize temp4 ;
29439 long val5 ;
29440 int ecode5 = 0 ;
29441 bool temp6 = false ;
29442 PyObject * obj0 = 0 ;
29443 PyObject * obj1 = 0 ;
29444 PyObject * obj2 = 0 ;
29445 PyObject * obj3 = 0 ;
29446 PyObject * obj4 = 0 ;
29447 PyObject * obj5 = 0 ;
29448 char * kwnames[] = {
29449 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29450 };
29451
29452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29454 if (!SWIG_IsOK(res1)) {
29455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29456 }
29457 arg1 = reinterpret_cast< wxWindow * >(argp1);
29458 if (obj1) {
29459 ecode2 = SWIG_AsVal_int(obj1, &val2);
29460 if (!SWIG_IsOK(ecode2)) {
29461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29462 }
29463 arg2 = static_cast< int >(val2);
29464 }
29465 if (obj2) {
29466 {
29467 arg3 = &temp3;
29468 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29469 }
29470 }
29471 if (obj3) {
29472 {
29473 arg4 = &temp4;
29474 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29475 }
29476 }
29477 if (obj4) {
29478 ecode5 = SWIG_AsVal_long(obj4, &val5);
29479 if (!SWIG_IsOK(ecode5)) {
29480 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29481 }
29482 arg5 = static_cast< long >(val5);
29483 }
29484 if (obj5) {
29485 {
29486 arg6 = wxString_in_helper(obj5);
29487 if (arg6 == NULL) SWIG_fail;
29488 temp6 = true;
29489 }
29490 }
29491 {
29492 if (!wxPyCheckForApp()) SWIG_fail;
29493 PyThreadState* __tstate = wxPyBeginAllowThreads();
29494 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29495 wxPyEndAllowThreads(__tstate);
29496 if (PyErr_Occurred()) SWIG_fail;
29497 }
29498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29499 {
29500 if (temp6)
29501 delete arg6;
29502 }
29503 return resultobj;
29504 fail:
29505 {
29506 if (temp6)
29507 delete arg6;
29508 }
29509 return NULL;
29510 }
29511
29512
29513 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29514 PyObject *resultobj = 0;
29515 wxWindow *result = 0 ;
29516
29517 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29518 {
29519 if (!wxPyCheckForApp()) SWIG_fail;
29520 PyThreadState* __tstate = wxPyBeginAllowThreads();
29521 result = (wxWindow *)new wxWindow();
29522 wxPyEndAllowThreads(__tstate);
29523 if (PyErr_Occurred()) SWIG_fail;
29524 }
29525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29526 return resultobj;
29527 fail:
29528 return NULL;
29529 }
29530
29531
29532 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29533 PyObject *resultobj = 0;
29534 wxWindow *arg1 = (wxWindow *) 0 ;
29535 wxWindow *arg2 = (wxWindow *) 0 ;
29536 int arg3 = (int) (int)-1 ;
29537 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29538 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29539 wxSize const &arg5_defvalue = wxDefaultSize ;
29540 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29541 long arg6 = (long) 0 ;
29542 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29543 wxString *arg7 = (wxString *) &arg7_defvalue ;
29544 bool result;
29545 void *argp1 = 0 ;
29546 int res1 = 0 ;
29547 void *argp2 = 0 ;
29548 int res2 = 0 ;
29549 int val3 ;
29550 int ecode3 = 0 ;
29551 wxPoint temp4 ;
29552 wxSize temp5 ;
29553 long val6 ;
29554 int ecode6 = 0 ;
29555 bool temp7 = false ;
29556 PyObject * obj0 = 0 ;
29557 PyObject * obj1 = 0 ;
29558 PyObject * obj2 = 0 ;
29559 PyObject * obj3 = 0 ;
29560 PyObject * obj4 = 0 ;
29561 PyObject * obj5 = 0 ;
29562 PyObject * obj6 = 0 ;
29563 char * kwnames[] = {
29564 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29565 };
29566
29567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29569 if (!SWIG_IsOK(res1)) {
29570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29571 }
29572 arg1 = reinterpret_cast< wxWindow * >(argp1);
29573 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29574 if (!SWIG_IsOK(res2)) {
29575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29576 }
29577 arg2 = reinterpret_cast< wxWindow * >(argp2);
29578 if (obj2) {
29579 ecode3 = SWIG_AsVal_int(obj2, &val3);
29580 if (!SWIG_IsOK(ecode3)) {
29581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29582 }
29583 arg3 = static_cast< int >(val3);
29584 }
29585 if (obj3) {
29586 {
29587 arg4 = &temp4;
29588 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29589 }
29590 }
29591 if (obj4) {
29592 {
29593 arg5 = &temp5;
29594 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29595 }
29596 }
29597 if (obj5) {
29598 ecode6 = SWIG_AsVal_long(obj5, &val6);
29599 if (!SWIG_IsOK(ecode6)) {
29600 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29601 }
29602 arg6 = static_cast< long >(val6);
29603 }
29604 if (obj6) {
29605 {
29606 arg7 = wxString_in_helper(obj6);
29607 if (arg7 == NULL) SWIG_fail;
29608 temp7 = true;
29609 }
29610 }
29611 {
29612 PyThreadState* __tstate = wxPyBeginAllowThreads();
29613 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29614 wxPyEndAllowThreads(__tstate);
29615 if (PyErr_Occurred()) SWIG_fail;
29616 }
29617 {
29618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29619 }
29620 {
29621 if (temp7)
29622 delete arg7;
29623 }
29624 return resultobj;
29625 fail:
29626 {
29627 if (temp7)
29628 delete arg7;
29629 }
29630 return NULL;
29631 }
29632
29633
29634 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29635 PyObject *resultobj = 0;
29636 wxWindow *arg1 = (wxWindow *) 0 ;
29637 bool arg2 = (bool) false ;
29638 bool result;
29639 void *argp1 = 0 ;
29640 int res1 = 0 ;
29641 bool val2 ;
29642 int ecode2 = 0 ;
29643 PyObject * obj0 = 0 ;
29644 PyObject * obj1 = 0 ;
29645 char * kwnames[] = {
29646 (char *) "self",(char *) "force", NULL
29647 };
29648
29649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29651 if (!SWIG_IsOK(res1)) {
29652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29653 }
29654 arg1 = reinterpret_cast< wxWindow * >(argp1);
29655 if (obj1) {
29656 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29657 if (!SWIG_IsOK(ecode2)) {
29658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29659 }
29660 arg2 = static_cast< bool >(val2);
29661 }
29662 {
29663 PyThreadState* __tstate = wxPyBeginAllowThreads();
29664 result = (bool)(arg1)->Close(arg2);
29665 wxPyEndAllowThreads(__tstate);
29666 if (PyErr_Occurred()) SWIG_fail;
29667 }
29668 {
29669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29670 }
29671 return resultobj;
29672 fail:
29673 return NULL;
29674 }
29675
29676
29677 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29678 PyObject *resultobj = 0;
29679 wxWindow *arg1 = (wxWindow *) 0 ;
29680 bool result;
29681 void *argp1 = 0 ;
29682 int res1 = 0 ;
29683 PyObject *swig_obj[1] ;
29684
29685 if (!args) SWIG_fail;
29686 swig_obj[0] = args;
29687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29688 if (!SWIG_IsOK(res1)) {
29689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29690 }
29691 arg1 = reinterpret_cast< wxWindow * >(argp1);
29692 {
29693 PyThreadState* __tstate = wxPyBeginAllowThreads();
29694 result = (bool)(arg1)->Destroy();
29695 wxPyEndAllowThreads(__tstate);
29696 if (PyErr_Occurred()) SWIG_fail;
29697 }
29698 {
29699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29700 }
29701 return resultobj;
29702 fail:
29703 return NULL;
29704 }
29705
29706
29707 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29708 PyObject *resultobj = 0;
29709 wxWindow *arg1 = (wxWindow *) 0 ;
29710 bool result;
29711 void *argp1 = 0 ;
29712 int res1 = 0 ;
29713 PyObject *swig_obj[1] ;
29714
29715 if (!args) SWIG_fail;
29716 swig_obj[0] = args;
29717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29718 if (!SWIG_IsOK(res1)) {
29719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29720 }
29721 arg1 = reinterpret_cast< wxWindow * >(argp1);
29722 {
29723 PyThreadState* __tstate = wxPyBeginAllowThreads();
29724 result = (bool)(arg1)->DestroyChildren();
29725 wxPyEndAllowThreads(__tstate);
29726 if (PyErr_Occurred()) SWIG_fail;
29727 }
29728 {
29729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29730 }
29731 return resultobj;
29732 fail:
29733 return NULL;
29734 }
29735
29736
29737 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29738 PyObject *resultobj = 0;
29739 wxWindow *arg1 = (wxWindow *) 0 ;
29740 bool result;
29741 void *argp1 = 0 ;
29742 int res1 = 0 ;
29743 PyObject *swig_obj[1] ;
29744
29745 if (!args) SWIG_fail;
29746 swig_obj[0] = args;
29747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29748 if (!SWIG_IsOK(res1)) {
29749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29750 }
29751 arg1 = reinterpret_cast< wxWindow * >(argp1);
29752 {
29753 PyThreadState* __tstate = wxPyBeginAllowThreads();
29754 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29755 wxPyEndAllowThreads(__tstate);
29756 if (PyErr_Occurred()) SWIG_fail;
29757 }
29758 {
29759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29760 }
29761 return resultobj;
29762 fail:
29763 return NULL;
29764 }
29765
29766
29767 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29768 PyObject *resultobj = 0;
29769 wxWindow *arg1 = (wxWindow *) 0 ;
29770 wxString *arg2 = 0 ;
29771 void *argp1 = 0 ;
29772 int res1 = 0 ;
29773 bool temp2 = false ;
29774 PyObject * obj0 = 0 ;
29775 PyObject * obj1 = 0 ;
29776 char * kwnames[] = {
29777 (char *) "self",(char *) "label", NULL
29778 };
29779
29780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29782 if (!SWIG_IsOK(res1)) {
29783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29784 }
29785 arg1 = reinterpret_cast< wxWindow * >(argp1);
29786 {
29787 arg2 = wxString_in_helper(obj1);
29788 if (arg2 == NULL) SWIG_fail;
29789 temp2 = true;
29790 }
29791 {
29792 PyThreadState* __tstate = wxPyBeginAllowThreads();
29793 (arg1)->SetLabel((wxString const &)*arg2);
29794 wxPyEndAllowThreads(__tstate);
29795 if (PyErr_Occurred()) SWIG_fail;
29796 }
29797 resultobj = SWIG_Py_Void();
29798 {
29799 if (temp2)
29800 delete arg2;
29801 }
29802 return resultobj;
29803 fail:
29804 {
29805 if (temp2)
29806 delete arg2;
29807 }
29808 return NULL;
29809 }
29810
29811
29812 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29813 PyObject *resultobj = 0;
29814 wxWindow *arg1 = (wxWindow *) 0 ;
29815 wxString result;
29816 void *argp1 = 0 ;
29817 int res1 = 0 ;
29818 PyObject *swig_obj[1] ;
29819
29820 if (!args) SWIG_fail;
29821 swig_obj[0] = args;
29822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29823 if (!SWIG_IsOK(res1)) {
29824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29825 }
29826 arg1 = reinterpret_cast< wxWindow * >(argp1);
29827 {
29828 PyThreadState* __tstate = wxPyBeginAllowThreads();
29829 result = ((wxWindow const *)arg1)->GetLabel();
29830 wxPyEndAllowThreads(__tstate);
29831 if (PyErr_Occurred()) SWIG_fail;
29832 }
29833 {
29834 #if wxUSE_UNICODE
29835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29836 #else
29837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29838 #endif
29839 }
29840 return resultobj;
29841 fail:
29842 return NULL;
29843 }
29844
29845
29846 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29847 PyObject *resultobj = 0;
29848 wxWindow *arg1 = (wxWindow *) 0 ;
29849 wxString *arg2 = 0 ;
29850 void *argp1 = 0 ;
29851 int res1 = 0 ;
29852 bool temp2 = false ;
29853 PyObject * obj0 = 0 ;
29854 PyObject * obj1 = 0 ;
29855 char * kwnames[] = {
29856 (char *) "self",(char *) "name", NULL
29857 };
29858
29859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29861 if (!SWIG_IsOK(res1)) {
29862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29863 }
29864 arg1 = reinterpret_cast< wxWindow * >(argp1);
29865 {
29866 arg2 = wxString_in_helper(obj1);
29867 if (arg2 == NULL) SWIG_fail;
29868 temp2 = true;
29869 }
29870 {
29871 PyThreadState* __tstate = wxPyBeginAllowThreads();
29872 (arg1)->SetName((wxString const &)*arg2);
29873 wxPyEndAllowThreads(__tstate);
29874 if (PyErr_Occurred()) SWIG_fail;
29875 }
29876 resultobj = SWIG_Py_Void();
29877 {
29878 if (temp2)
29879 delete arg2;
29880 }
29881 return resultobj;
29882 fail:
29883 {
29884 if (temp2)
29885 delete arg2;
29886 }
29887 return NULL;
29888 }
29889
29890
29891 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29892 PyObject *resultobj = 0;
29893 wxWindow *arg1 = (wxWindow *) 0 ;
29894 wxString result;
29895 void *argp1 = 0 ;
29896 int res1 = 0 ;
29897 PyObject *swig_obj[1] ;
29898
29899 if (!args) SWIG_fail;
29900 swig_obj[0] = args;
29901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29902 if (!SWIG_IsOK(res1)) {
29903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29904 }
29905 arg1 = reinterpret_cast< wxWindow * >(argp1);
29906 {
29907 PyThreadState* __tstate = wxPyBeginAllowThreads();
29908 result = ((wxWindow const *)arg1)->GetName();
29909 wxPyEndAllowThreads(__tstate);
29910 if (PyErr_Occurred()) SWIG_fail;
29911 }
29912 {
29913 #if wxUSE_UNICODE
29914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29915 #else
29916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29917 #endif
29918 }
29919 return resultobj;
29920 fail:
29921 return NULL;
29922 }
29923
29924
29925 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29926 PyObject *resultobj = 0;
29927 wxWindow *arg1 = (wxWindow *) 0 ;
29928 wxWindowVariant arg2 ;
29929 void *argp1 = 0 ;
29930 int res1 = 0 ;
29931 int val2 ;
29932 int ecode2 = 0 ;
29933 PyObject * obj0 = 0 ;
29934 PyObject * obj1 = 0 ;
29935 char * kwnames[] = {
29936 (char *) "self",(char *) "variant", NULL
29937 };
29938
29939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29941 if (!SWIG_IsOK(res1)) {
29942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29943 }
29944 arg1 = reinterpret_cast< wxWindow * >(argp1);
29945 ecode2 = SWIG_AsVal_int(obj1, &val2);
29946 if (!SWIG_IsOK(ecode2)) {
29947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29948 }
29949 arg2 = static_cast< wxWindowVariant >(val2);
29950 {
29951 PyThreadState* __tstate = wxPyBeginAllowThreads();
29952 (arg1)->SetWindowVariant(arg2);
29953 wxPyEndAllowThreads(__tstate);
29954 if (PyErr_Occurred()) SWIG_fail;
29955 }
29956 resultobj = SWIG_Py_Void();
29957 return resultobj;
29958 fail:
29959 return NULL;
29960 }
29961
29962
29963 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29964 PyObject *resultobj = 0;
29965 wxWindow *arg1 = (wxWindow *) 0 ;
29966 wxWindowVariant result;
29967 void *argp1 = 0 ;
29968 int res1 = 0 ;
29969 PyObject *swig_obj[1] ;
29970
29971 if (!args) SWIG_fail;
29972 swig_obj[0] = args;
29973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29974 if (!SWIG_IsOK(res1)) {
29975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29976 }
29977 arg1 = reinterpret_cast< wxWindow * >(argp1);
29978 {
29979 PyThreadState* __tstate = wxPyBeginAllowThreads();
29980 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29981 wxPyEndAllowThreads(__tstate);
29982 if (PyErr_Occurred()) SWIG_fail;
29983 }
29984 resultobj = SWIG_From_int(static_cast< int >(result));
29985 return resultobj;
29986 fail:
29987 return NULL;
29988 }
29989
29990
29991 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29992 PyObject *resultobj = 0;
29993 wxWindow *arg1 = (wxWindow *) 0 ;
29994 int arg2 ;
29995 void *argp1 = 0 ;
29996 int res1 = 0 ;
29997 int val2 ;
29998 int ecode2 = 0 ;
29999 PyObject * obj0 = 0 ;
30000 PyObject * obj1 = 0 ;
30001 char * kwnames[] = {
30002 (char *) "self",(char *) "winid", NULL
30003 };
30004
30005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30007 if (!SWIG_IsOK(res1)) {
30008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30009 }
30010 arg1 = reinterpret_cast< wxWindow * >(argp1);
30011 ecode2 = SWIG_AsVal_int(obj1, &val2);
30012 if (!SWIG_IsOK(ecode2)) {
30013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30014 }
30015 arg2 = static_cast< int >(val2);
30016 {
30017 PyThreadState* __tstate = wxPyBeginAllowThreads();
30018 (arg1)->SetId(arg2);
30019 wxPyEndAllowThreads(__tstate);
30020 if (PyErr_Occurred()) SWIG_fail;
30021 }
30022 resultobj = SWIG_Py_Void();
30023 return resultobj;
30024 fail:
30025 return NULL;
30026 }
30027
30028
30029 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30030 PyObject *resultobj = 0;
30031 wxWindow *arg1 = (wxWindow *) 0 ;
30032 int result;
30033 void *argp1 = 0 ;
30034 int res1 = 0 ;
30035 PyObject *swig_obj[1] ;
30036
30037 if (!args) SWIG_fail;
30038 swig_obj[0] = args;
30039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30040 if (!SWIG_IsOK(res1)) {
30041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30042 }
30043 arg1 = reinterpret_cast< wxWindow * >(argp1);
30044 {
30045 PyThreadState* __tstate = wxPyBeginAllowThreads();
30046 result = (int)((wxWindow const *)arg1)->GetId();
30047 wxPyEndAllowThreads(__tstate);
30048 if (PyErr_Occurred()) SWIG_fail;
30049 }
30050 resultobj = SWIG_From_int(static_cast< int >(result));
30051 return resultobj;
30052 fail:
30053 return NULL;
30054 }
30055
30056
30057 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30058 PyObject *resultobj = 0;
30059 int result;
30060
30061 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30062 {
30063 PyThreadState* __tstate = wxPyBeginAllowThreads();
30064 result = (int)wxWindow::NewControlId();
30065 wxPyEndAllowThreads(__tstate);
30066 if (PyErr_Occurred()) SWIG_fail;
30067 }
30068 resultobj = SWIG_From_int(static_cast< int >(result));
30069 return resultobj;
30070 fail:
30071 return NULL;
30072 }
30073
30074
30075 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30076 PyObject *resultobj = 0;
30077 int arg1 ;
30078 int result;
30079 int val1 ;
30080 int ecode1 = 0 ;
30081 PyObject * obj0 = 0 ;
30082 char * kwnames[] = {
30083 (char *) "winid", NULL
30084 };
30085
30086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30087 ecode1 = SWIG_AsVal_int(obj0, &val1);
30088 if (!SWIG_IsOK(ecode1)) {
30089 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30090 }
30091 arg1 = static_cast< int >(val1);
30092 {
30093 PyThreadState* __tstate = wxPyBeginAllowThreads();
30094 result = (int)wxWindow::NextControlId(arg1);
30095 wxPyEndAllowThreads(__tstate);
30096 if (PyErr_Occurred()) SWIG_fail;
30097 }
30098 resultobj = SWIG_From_int(static_cast< int >(result));
30099 return resultobj;
30100 fail:
30101 return NULL;
30102 }
30103
30104
30105 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30106 PyObject *resultobj = 0;
30107 int arg1 ;
30108 int result;
30109 int val1 ;
30110 int ecode1 = 0 ;
30111 PyObject * obj0 = 0 ;
30112 char * kwnames[] = {
30113 (char *) "winid", NULL
30114 };
30115
30116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30117 ecode1 = SWIG_AsVal_int(obj0, &val1);
30118 if (!SWIG_IsOK(ecode1)) {
30119 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30120 }
30121 arg1 = static_cast< int >(val1);
30122 {
30123 PyThreadState* __tstate = wxPyBeginAllowThreads();
30124 result = (int)wxWindow::PrevControlId(arg1);
30125 wxPyEndAllowThreads(__tstate);
30126 if (PyErr_Occurred()) SWIG_fail;
30127 }
30128 resultobj = SWIG_From_int(static_cast< int >(result));
30129 return resultobj;
30130 fail:
30131 return NULL;
30132 }
30133
30134
30135 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30136 PyObject *resultobj = 0;
30137 wxWindow *arg1 = (wxWindow *) 0 ;
30138 wxSize *arg2 = 0 ;
30139 void *argp1 = 0 ;
30140 int res1 = 0 ;
30141 wxSize temp2 ;
30142 PyObject * obj0 = 0 ;
30143 PyObject * obj1 = 0 ;
30144 char * kwnames[] = {
30145 (char *) "self",(char *) "size", NULL
30146 };
30147
30148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30150 if (!SWIG_IsOK(res1)) {
30151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30152 }
30153 arg1 = reinterpret_cast< wxWindow * >(argp1);
30154 {
30155 arg2 = &temp2;
30156 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30157 }
30158 {
30159 PyThreadState* __tstate = wxPyBeginAllowThreads();
30160 (arg1)->SetSize((wxSize const &)*arg2);
30161 wxPyEndAllowThreads(__tstate);
30162 if (PyErr_Occurred()) SWIG_fail;
30163 }
30164 resultobj = SWIG_Py_Void();
30165 return resultobj;
30166 fail:
30167 return NULL;
30168 }
30169
30170
30171 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30172 PyObject *resultobj = 0;
30173 wxWindow *arg1 = (wxWindow *) 0 ;
30174 int arg2 ;
30175 int arg3 ;
30176 int arg4 ;
30177 int arg5 ;
30178 int arg6 = (int) wxSIZE_AUTO ;
30179 void *argp1 = 0 ;
30180 int res1 = 0 ;
30181 int val2 ;
30182 int ecode2 = 0 ;
30183 int val3 ;
30184 int ecode3 = 0 ;
30185 int val4 ;
30186 int ecode4 = 0 ;
30187 int val5 ;
30188 int ecode5 = 0 ;
30189 int val6 ;
30190 int ecode6 = 0 ;
30191 PyObject * obj0 = 0 ;
30192 PyObject * obj1 = 0 ;
30193 PyObject * obj2 = 0 ;
30194 PyObject * obj3 = 0 ;
30195 PyObject * obj4 = 0 ;
30196 PyObject * obj5 = 0 ;
30197 char * kwnames[] = {
30198 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30199 };
30200
30201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30203 if (!SWIG_IsOK(res1)) {
30204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30205 }
30206 arg1 = reinterpret_cast< wxWindow * >(argp1);
30207 ecode2 = SWIG_AsVal_int(obj1, &val2);
30208 if (!SWIG_IsOK(ecode2)) {
30209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30210 }
30211 arg2 = static_cast< int >(val2);
30212 ecode3 = SWIG_AsVal_int(obj2, &val3);
30213 if (!SWIG_IsOK(ecode3)) {
30214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30215 }
30216 arg3 = static_cast< int >(val3);
30217 ecode4 = SWIG_AsVal_int(obj3, &val4);
30218 if (!SWIG_IsOK(ecode4)) {
30219 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30220 }
30221 arg4 = static_cast< int >(val4);
30222 ecode5 = SWIG_AsVal_int(obj4, &val5);
30223 if (!SWIG_IsOK(ecode5)) {
30224 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30225 }
30226 arg5 = static_cast< int >(val5);
30227 if (obj5) {
30228 ecode6 = SWIG_AsVal_int(obj5, &val6);
30229 if (!SWIG_IsOK(ecode6)) {
30230 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30231 }
30232 arg6 = static_cast< int >(val6);
30233 }
30234 {
30235 PyThreadState* __tstate = wxPyBeginAllowThreads();
30236 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30237 wxPyEndAllowThreads(__tstate);
30238 if (PyErr_Occurred()) SWIG_fail;
30239 }
30240 resultobj = SWIG_Py_Void();
30241 return resultobj;
30242 fail:
30243 return NULL;
30244 }
30245
30246
30247 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30248 PyObject *resultobj = 0;
30249 wxWindow *arg1 = (wxWindow *) 0 ;
30250 wxRect *arg2 = 0 ;
30251 int arg3 = (int) wxSIZE_AUTO ;
30252 void *argp1 = 0 ;
30253 int res1 = 0 ;
30254 wxRect temp2 ;
30255 int val3 ;
30256 int ecode3 = 0 ;
30257 PyObject * obj0 = 0 ;
30258 PyObject * obj1 = 0 ;
30259 PyObject * obj2 = 0 ;
30260 char * kwnames[] = {
30261 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30262 };
30263
30264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30266 if (!SWIG_IsOK(res1)) {
30267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30268 }
30269 arg1 = reinterpret_cast< wxWindow * >(argp1);
30270 {
30271 arg2 = &temp2;
30272 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30273 }
30274 if (obj2) {
30275 ecode3 = SWIG_AsVal_int(obj2, &val3);
30276 if (!SWIG_IsOK(ecode3)) {
30277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30278 }
30279 arg3 = static_cast< int >(val3);
30280 }
30281 {
30282 PyThreadState* __tstate = wxPyBeginAllowThreads();
30283 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30284 wxPyEndAllowThreads(__tstate);
30285 if (PyErr_Occurred()) SWIG_fail;
30286 }
30287 resultobj = SWIG_Py_Void();
30288 return resultobj;
30289 fail:
30290 return NULL;
30291 }
30292
30293
30294 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30295 PyObject *resultobj = 0;
30296 wxWindow *arg1 = (wxWindow *) 0 ;
30297 int arg2 ;
30298 int arg3 ;
30299 void *argp1 = 0 ;
30300 int res1 = 0 ;
30301 int val2 ;
30302 int ecode2 = 0 ;
30303 int val3 ;
30304 int ecode3 = 0 ;
30305 PyObject * obj0 = 0 ;
30306 PyObject * obj1 = 0 ;
30307 PyObject * obj2 = 0 ;
30308 char * kwnames[] = {
30309 (char *) "self",(char *) "width",(char *) "height", NULL
30310 };
30311
30312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30314 if (!SWIG_IsOK(res1)) {
30315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30316 }
30317 arg1 = reinterpret_cast< wxWindow * >(argp1);
30318 ecode2 = SWIG_AsVal_int(obj1, &val2);
30319 if (!SWIG_IsOK(ecode2)) {
30320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30321 }
30322 arg2 = static_cast< int >(val2);
30323 ecode3 = SWIG_AsVal_int(obj2, &val3);
30324 if (!SWIG_IsOK(ecode3)) {
30325 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30326 }
30327 arg3 = static_cast< int >(val3);
30328 {
30329 PyThreadState* __tstate = wxPyBeginAllowThreads();
30330 (arg1)->SetSize(arg2,arg3);
30331 wxPyEndAllowThreads(__tstate);
30332 if (PyErr_Occurred()) SWIG_fail;
30333 }
30334 resultobj = SWIG_Py_Void();
30335 return resultobj;
30336 fail:
30337 return NULL;
30338 }
30339
30340
30341 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30342 PyObject *resultobj = 0;
30343 wxWindow *arg1 = (wxWindow *) 0 ;
30344 wxPoint *arg2 = 0 ;
30345 int arg3 = (int) wxSIZE_USE_EXISTING ;
30346 void *argp1 = 0 ;
30347 int res1 = 0 ;
30348 wxPoint temp2 ;
30349 int val3 ;
30350 int ecode3 = 0 ;
30351 PyObject * obj0 = 0 ;
30352 PyObject * obj1 = 0 ;
30353 PyObject * obj2 = 0 ;
30354 char * kwnames[] = {
30355 (char *) "self",(char *) "pt",(char *) "flags", NULL
30356 };
30357
30358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30360 if (!SWIG_IsOK(res1)) {
30361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30362 }
30363 arg1 = reinterpret_cast< wxWindow * >(argp1);
30364 {
30365 arg2 = &temp2;
30366 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30367 }
30368 if (obj2) {
30369 ecode3 = SWIG_AsVal_int(obj2, &val3);
30370 if (!SWIG_IsOK(ecode3)) {
30371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30372 }
30373 arg3 = static_cast< int >(val3);
30374 }
30375 {
30376 PyThreadState* __tstate = wxPyBeginAllowThreads();
30377 (arg1)->Move((wxPoint const &)*arg2,arg3);
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_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30389 PyObject *resultobj = 0;
30390 wxWindow *arg1 = (wxWindow *) 0 ;
30391 int arg2 ;
30392 int arg3 ;
30393 int arg4 = (int) wxSIZE_USE_EXISTING ;
30394 void *argp1 = 0 ;
30395 int res1 = 0 ;
30396 int val2 ;
30397 int ecode2 = 0 ;
30398 int val3 ;
30399 int ecode3 = 0 ;
30400 int val4 ;
30401 int ecode4 = 0 ;
30402 PyObject * obj0 = 0 ;
30403 PyObject * obj1 = 0 ;
30404 PyObject * obj2 = 0 ;
30405 PyObject * obj3 = 0 ;
30406 char * kwnames[] = {
30407 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30408 };
30409
30410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30412 if (!SWIG_IsOK(res1)) {
30413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30414 }
30415 arg1 = reinterpret_cast< wxWindow * >(argp1);
30416 ecode2 = SWIG_AsVal_int(obj1, &val2);
30417 if (!SWIG_IsOK(ecode2)) {
30418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30419 }
30420 arg2 = static_cast< int >(val2);
30421 ecode3 = SWIG_AsVal_int(obj2, &val3);
30422 if (!SWIG_IsOK(ecode3)) {
30423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30424 }
30425 arg3 = static_cast< int >(val3);
30426 if (obj3) {
30427 ecode4 = SWIG_AsVal_int(obj3, &val4);
30428 if (!SWIG_IsOK(ecode4)) {
30429 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30430 }
30431 arg4 = static_cast< int >(val4);
30432 }
30433 {
30434 PyThreadState* __tstate = wxPyBeginAllowThreads();
30435 (arg1)->Move(arg2,arg3,arg4);
30436 wxPyEndAllowThreads(__tstate);
30437 if (PyErr_Occurred()) SWIG_fail;
30438 }
30439 resultobj = SWIG_Py_Void();
30440 return resultobj;
30441 fail:
30442 return NULL;
30443 }
30444
30445
30446 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30447 PyObject *resultobj = 0;
30448 wxWindow *arg1 = (wxWindow *) 0 ;
30449 wxSize const &arg2_defvalue = wxDefaultSize ;
30450 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30451 void *argp1 = 0 ;
30452 int res1 = 0 ;
30453 wxSize temp2 ;
30454 PyObject * obj0 = 0 ;
30455 PyObject * obj1 = 0 ;
30456 char * kwnames[] = {
30457 (char *) "self",(char *) "size", NULL
30458 };
30459
30460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30462 if (!SWIG_IsOK(res1)) {
30463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30464 }
30465 arg1 = reinterpret_cast< wxWindow * >(argp1);
30466 if (obj1) {
30467 {
30468 arg2 = &temp2;
30469 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30470 }
30471 }
30472 {
30473 PyThreadState* __tstate = wxPyBeginAllowThreads();
30474 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30475 wxPyEndAllowThreads(__tstate);
30476 if (PyErr_Occurred()) SWIG_fail;
30477 }
30478 resultobj = SWIG_Py_Void();
30479 return resultobj;
30480 fail:
30481 return NULL;
30482 }
30483
30484
30485 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30486 PyObject *resultobj = 0;
30487 wxWindow *arg1 = (wxWindow *) 0 ;
30488 void *argp1 = 0 ;
30489 int res1 = 0 ;
30490 PyObject *swig_obj[1] ;
30491
30492 if (!args) SWIG_fail;
30493 swig_obj[0] = args;
30494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30495 if (!SWIG_IsOK(res1)) {
30496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30497 }
30498 arg1 = reinterpret_cast< wxWindow * >(argp1);
30499 {
30500 PyThreadState* __tstate = wxPyBeginAllowThreads();
30501 (arg1)->Raise();
30502 wxPyEndAllowThreads(__tstate);
30503 if (PyErr_Occurred()) SWIG_fail;
30504 }
30505 resultobj = SWIG_Py_Void();
30506 return resultobj;
30507 fail:
30508 return NULL;
30509 }
30510
30511
30512 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30513 PyObject *resultobj = 0;
30514 wxWindow *arg1 = (wxWindow *) 0 ;
30515 void *argp1 = 0 ;
30516 int res1 = 0 ;
30517 PyObject *swig_obj[1] ;
30518
30519 if (!args) SWIG_fail;
30520 swig_obj[0] = args;
30521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30522 if (!SWIG_IsOK(res1)) {
30523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30524 }
30525 arg1 = reinterpret_cast< wxWindow * >(argp1);
30526 {
30527 PyThreadState* __tstate = wxPyBeginAllowThreads();
30528 (arg1)->Lower();
30529 wxPyEndAllowThreads(__tstate);
30530 if (PyErr_Occurred()) SWIG_fail;
30531 }
30532 resultobj = SWIG_Py_Void();
30533 return resultobj;
30534 fail:
30535 return NULL;
30536 }
30537
30538
30539 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30540 PyObject *resultobj = 0;
30541 wxWindow *arg1 = (wxWindow *) 0 ;
30542 wxSize *arg2 = 0 ;
30543 void *argp1 = 0 ;
30544 int res1 = 0 ;
30545 wxSize temp2 ;
30546 PyObject * obj0 = 0 ;
30547 PyObject * obj1 = 0 ;
30548 char * kwnames[] = {
30549 (char *) "self",(char *) "size", NULL
30550 };
30551
30552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30554 if (!SWIG_IsOK(res1)) {
30555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30556 }
30557 arg1 = reinterpret_cast< wxWindow * >(argp1);
30558 {
30559 arg2 = &temp2;
30560 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30561 }
30562 {
30563 PyThreadState* __tstate = wxPyBeginAllowThreads();
30564 (arg1)->SetClientSize((wxSize const &)*arg2);
30565 wxPyEndAllowThreads(__tstate);
30566 if (PyErr_Occurred()) SWIG_fail;
30567 }
30568 resultobj = SWIG_Py_Void();
30569 return resultobj;
30570 fail:
30571 return NULL;
30572 }
30573
30574
30575 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30576 PyObject *resultobj = 0;
30577 wxWindow *arg1 = (wxWindow *) 0 ;
30578 int arg2 ;
30579 int arg3 ;
30580 void *argp1 = 0 ;
30581 int res1 = 0 ;
30582 int val2 ;
30583 int ecode2 = 0 ;
30584 int val3 ;
30585 int ecode3 = 0 ;
30586 PyObject * obj0 = 0 ;
30587 PyObject * obj1 = 0 ;
30588 PyObject * obj2 = 0 ;
30589 char * kwnames[] = {
30590 (char *) "self",(char *) "width",(char *) "height", NULL
30591 };
30592
30593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30595 if (!SWIG_IsOK(res1)) {
30596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30597 }
30598 arg1 = reinterpret_cast< wxWindow * >(argp1);
30599 ecode2 = SWIG_AsVal_int(obj1, &val2);
30600 if (!SWIG_IsOK(ecode2)) {
30601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30602 }
30603 arg2 = static_cast< int >(val2);
30604 ecode3 = SWIG_AsVal_int(obj2, &val3);
30605 if (!SWIG_IsOK(ecode3)) {
30606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30607 }
30608 arg3 = static_cast< int >(val3);
30609 {
30610 PyThreadState* __tstate = wxPyBeginAllowThreads();
30611 (arg1)->SetClientSize(arg2,arg3);
30612 wxPyEndAllowThreads(__tstate);
30613 if (PyErr_Occurred()) SWIG_fail;
30614 }
30615 resultobj = SWIG_Py_Void();
30616 return resultobj;
30617 fail:
30618 return NULL;
30619 }
30620
30621
30622 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30623 PyObject *resultobj = 0;
30624 wxWindow *arg1 = (wxWindow *) 0 ;
30625 wxRect *arg2 = 0 ;
30626 void *argp1 = 0 ;
30627 int res1 = 0 ;
30628 wxRect temp2 ;
30629 PyObject * obj0 = 0 ;
30630 PyObject * obj1 = 0 ;
30631 char * kwnames[] = {
30632 (char *) "self",(char *) "rect", NULL
30633 };
30634
30635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30637 if (!SWIG_IsOK(res1)) {
30638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30639 }
30640 arg1 = reinterpret_cast< wxWindow * >(argp1);
30641 {
30642 arg2 = &temp2;
30643 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30644 }
30645 {
30646 PyThreadState* __tstate = wxPyBeginAllowThreads();
30647 (arg1)->SetClientSize((wxRect const &)*arg2);
30648 wxPyEndAllowThreads(__tstate);
30649 if (PyErr_Occurred()) SWIG_fail;
30650 }
30651 resultobj = SWIG_Py_Void();
30652 return resultobj;
30653 fail:
30654 return NULL;
30655 }
30656
30657
30658 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30659 PyObject *resultobj = 0;
30660 wxWindow *arg1 = (wxWindow *) 0 ;
30661 wxPoint result;
30662 void *argp1 = 0 ;
30663 int res1 = 0 ;
30664 PyObject *swig_obj[1] ;
30665
30666 if (!args) SWIG_fail;
30667 swig_obj[0] = args;
30668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30669 if (!SWIG_IsOK(res1)) {
30670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30671 }
30672 arg1 = reinterpret_cast< wxWindow * >(argp1);
30673 {
30674 PyThreadState* __tstate = wxPyBeginAllowThreads();
30675 result = ((wxWindow const *)arg1)->GetPosition();
30676 wxPyEndAllowThreads(__tstate);
30677 if (PyErr_Occurred()) SWIG_fail;
30678 }
30679 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30680 return resultobj;
30681 fail:
30682 return NULL;
30683 }
30684
30685
30686 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30687 PyObject *resultobj = 0;
30688 wxWindow *arg1 = (wxWindow *) 0 ;
30689 int *arg2 = (int *) 0 ;
30690 int *arg3 = (int *) 0 ;
30691 void *argp1 = 0 ;
30692 int res1 = 0 ;
30693 int temp2 ;
30694 int res2 = SWIG_TMPOBJ ;
30695 int temp3 ;
30696 int res3 = SWIG_TMPOBJ ;
30697 PyObject *swig_obj[1] ;
30698
30699 arg2 = &temp2;
30700 arg3 = &temp3;
30701 if (!args) SWIG_fail;
30702 swig_obj[0] = args;
30703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30704 if (!SWIG_IsOK(res1)) {
30705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30706 }
30707 arg1 = reinterpret_cast< wxWindow * >(argp1);
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30711 wxPyEndAllowThreads(__tstate);
30712 if (PyErr_Occurred()) SWIG_fail;
30713 }
30714 resultobj = SWIG_Py_Void();
30715 if (SWIG_IsTmpObj(res2)) {
30716 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30717 } else {
30718 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30719 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30720 }
30721 if (SWIG_IsTmpObj(res3)) {
30722 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30723 } else {
30724 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30726 }
30727 return resultobj;
30728 fail:
30729 return NULL;
30730 }
30731
30732
30733 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30734 PyObject *resultobj = 0;
30735 wxWindow *arg1 = (wxWindow *) 0 ;
30736 wxPoint result;
30737 void *argp1 = 0 ;
30738 int res1 = 0 ;
30739 PyObject *swig_obj[1] ;
30740
30741 if (!args) SWIG_fail;
30742 swig_obj[0] = args;
30743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30744 if (!SWIG_IsOK(res1)) {
30745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30746 }
30747 arg1 = reinterpret_cast< wxWindow * >(argp1);
30748 {
30749 PyThreadState* __tstate = wxPyBeginAllowThreads();
30750 result = ((wxWindow const *)arg1)->GetScreenPosition();
30751 wxPyEndAllowThreads(__tstate);
30752 if (PyErr_Occurred()) SWIG_fail;
30753 }
30754 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30755 return resultobj;
30756 fail:
30757 return NULL;
30758 }
30759
30760
30761 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30762 PyObject *resultobj = 0;
30763 wxWindow *arg1 = (wxWindow *) 0 ;
30764 int *arg2 = (int *) 0 ;
30765 int *arg3 = (int *) 0 ;
30766 void *argp1 = 0 ;
30767 int res1 = 0 ;
30768 int temp2 ;
30769 int res2 = SWIG_TMPOBJ ;
30770 int temp3 ;
30771 int res3 = SWIG_TMPOBJ ;
30772 PyObject *swig_obj[1] ;
30773
30774 arg2 = &temp2;
30775 arg3 = &temp3;
30776 if (!args) SWIG_fail;
30777 swig_obj[0] = args;
30778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30779 if (!SWIG_IsOK(res1)) {
30780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30781 }
30782 arg1 = reinterpret_cast< wxWindow * >(argp1);
30783 {
30784 PyThreadState* __tstate = wxPyBeginAllowThreads();
30785 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30786 wxPyEndAllowThreads(__tstate);
30787 if (PyErr_Occurred()) SWIG_fail;
30788 }
30789 resultobj = SWIG_Py_Void();
30790 if (SWIG_IsTmpObj(res2)) {
30791 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30792 } else {
30793 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30794 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30795 }
30796 if (SWIG_IsTmpObj(res3)) {
30797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30798 } else {
30799 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30800 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30801 }
30802 return resultobj;
30803 fail:
30804 return NULL;
30805 }
30806
30807
30808 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30809 PyObject *resultobj = 0;
30810 wxWindow *arg1 = (wxWindow *) 0 ;
30811 wxRect result;
30812 void *argp1 = 0 ;
30813 int res1 = 0 ;
30814 PyObject *swig_obj[1] ;
30815
30816 if (!args) SWIG_fail;
30817 swig_obj[0] = args;
30818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30819 if (!SWIG_IsOK(res1)) {
30820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30821 }
30822 arg1 = reinterpret_cast< wxWindow * >(argp1);
30823 {
30824 PyThreadState* __tstate = wxPyBeginAllowThreads();
30825 result = ((wxWindow const *)arg1)->GetScreenRect();
30826 wxPyEndAllowThreads(__tstate);
30827 if (PyErr_Occurred()) SWIG_fail;
30828 }
30829 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30830 return resultobj;
30831 fail:
30832 return NULL;
30833 }
30834
30835
30836 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30837 PyObject *resultobj = 0;
30838 wxWindow *arg1 = (wxWindow *) 0 ;
30839 wxSize result;
30840 void *argp1 = 0 ;
30841 int res1 = 0 ;
30842 PyObject *swig_obj[1] ;
30843
30844 if (!args) SWIG_fail;
30845 swig_obj[0] = args;
30846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30847 if (!SWIG_IsOK(res1)) {
30848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30849 }
30850 arg1 = reinterpret_cast< wxWindow * >(argp1);
30851 {
30852 PyThreadState* __tstate = wxPyBeginAllowThreads();
30853 result = ((wxWindow const *)arg1)->GetSize();
30854 wxPyEndAllowThreads(__tstate);
30855 if (PyErr_Occurred()) SWIG_fail;
30856 }
30857 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30858 return resultobj;
30859 fail:
30860 return NULL;
30861 }
30862
30863
30864 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30865 PyObject *resultobj = 0;
30866 wxWindow *arg1 = (wxWindow *) 0 ;
30867 int *arg2 = (int *) 0 ;
30868 int *arg3 = (int *) 0 ;
30869 void *argp1 = 0 ;
30870 int res1 = 0 ;
30871 int temp2 ;
30872 int res2 = SWIG_TMPOBJ ;
30873 int temp3 ;
30874 int res3 = SWIG_TMPOBJ ;
30875 PyObject *swig_obj[1] ;
30876
30877 arg2 = &temp2;
30878 arg3 = &temp3;
30879 if (!args) SWIG_fail;
30880 swig_obj[0] = args;
30881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30882 if (!SWIG_IsOK(res1)) {
30883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30884 }
30885 arg1 = reinterpret_cast< wxWindow * >(argp1);
30886 {
30887 PyThreadState* __tstate = wxPyBeginAllowThreads();
30888 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30889 wxPyEndAllowThreads(__tstate);
30890 if (PyErr_Occurred()) SWIG_fail;
30891 }
30892 resultobj = SWIG_Py_Void();
30893 if (SWIG_IsTmpObj(res2)) {
30894 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30895 } else {
30896 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30897 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30898 }
30899 if (SWIG_IsTmpObj(res3)) {
30900 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30901 } else {
30902 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30903 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30904 }
30905 return resultobj;
30906 fail:
30907 return NULL;
30908 }
30909
30910
30911 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30912 PyObject *resultobj = 0;
30913 wxWindow *arg1 = (wxWindow *) 0 ;
30914 wxRect result;
30915 void *argp1 = 0 ;
30916 int res1 = 0 ;
30917 PyObject *swig_obj[1] ;
30918
30919 if (!args) SWIG_fail;
30920 swig_obj[0] = args;
30921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30922 if (!SWIG_IsOK(res1)) {
30923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30924 }
30925 arg1 = reinterpret_cast< wxWindow * >(argp1);
30926 {
30927 PyThreadState* __tstate = wxPyBeginAllowThreads();
30928 result = ((wxWindow const *)arg1)->GetRect();
30929 wxPyEndAllowThreads(__tstate);
30930 if (PyErr_Occurred()) SWIG_fail;
30931 }
30932 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30933 return resultobj;
30934 fail:
30935 return NULL;
30936 }
30937
30938
30939 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30940 PyObject *resultobj = 0;
30941 wxWindow *arg1 = (wxWindow *) 0 ;
30942 wxSize result;
30943 void *argp1 = 0 ;
30944 int res1 = 0 ;
30945 PyObject *swig_obj[1] ;
30946
30947 if (!args) SWIG_fail;
30948 swig_obj[0] = args;
30949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30950 if (!SWIG_IsOK(res1)) {
30951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30952 }
30953 arg1 = reinterpret_cast< wxWindow * >(argp1);
30954 {
30955 PyThreadState* __tstate = wxPyBeginAllowThreads();
30956 result = ((wxWindow const *)arg1)->GetClientSize();
30957 wxPyEndAllowThreads(__tstate);
30958 if (PyErr_Occurred()) SWIG_fail;
30959 }
30960 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30961 return resultobj;
30962 fail:
30963 return NULL;
30964 }
30965
30966
30967 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30968 PyObject *resultobj = 0;
30969 wxWindow *arg1 = (wxWindow *) 0 ;
30970 int *arg2 = (int *) 0 ;
30971 int *arg3 = (int *) 0 ;
30972 void *argp1 = 0 ;
30973 int res1 = 0 ;
30974 int temp2 ;
30975 int res2 = SWIG_TMPOBJ ;
30976 int temp3 ;
30977 int res3 = SWIG_TMPOBJ ;
30978 PyObject *swig_obj[1] ;
30979
30980 arg2 = &temp2;
30981 arg3 = &temp3;
30982 if (!args) SWIG_fail;
30983 swig_obj[0] = args;
30984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30985 if (!SWIG_IsOK(res1)) {
30986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30987 }
30988 arg1 = reinterpret_cast< wxWindow * >(argp1);
30989 {
30990 PyThreadState* __tstate = wxPyBeginAllowThreads();
30991 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30992 wxPyEndAllowThreads(__tstate);
30993 if (PyErr_Occurred()) SWIG_fail;
30994 }
30995 resultobj = SWIG_Py_Void();
30996 if (SWIG_IsTmpObj(res2)) {
30997 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30998 } else {
30999 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31001 }
31002 if (SWIG_IsTmpObj(res3)) {
31003 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31004 } else {
31005 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31007 }
31008 return resultobj;
31009 fail:
31010 return NULL;
31011 }
31012
31013
31014 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31015 PyObject *resultobj = 0;
31016 wxWindow *arg1 = (wxWindow *) 0 ;
31017 wxPoint result;
31018 void *argp1 = 0 ;
31019 int res1 = 0 ;
31020 PyObject *swig_obj[1] ;
31021
31022 if (!args) SWIG_fail;
31023 swig_obj[0] = args;
31024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31025 if (!SWIG_IsOK(res1)) {
31026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31027 }
31028 arg1 = reinterpret_cast< wxWindow * >(argp1);
31029 {
31030 PyThreadState* __tstate = wxPyBeginAllowThreads();
31031 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31032 wxPyEndAllowThreads(__tstate);
31033 if (PyErr_Occurred()) SWIG_fail;
31034 }
31035 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31036 return resultobj;
31037 fail:
31038 return NULL;
31039 }
31040
31041
31042 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31043 PyObject *resultobj = 0;
31044 wxWindow *arg1 = (wxWindow *) 0 ;
31045 wxRect result;
31046 void *argp1 = 0 ;
31047 int res1 = 0 ;
31048 PyObject *swig_obj[1] ;
31049
31050 if (!args) SWIG_fail;
31051 swig_obj[0] = args;
31052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31053 if (!SWIG_IsOK(res1)) {
31054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31055 }
31056 arg1 = reinterpret_cast< wxWindow * >(argp1);
31057 {
31058 PyThreadState* __tstate = wxPyBeginAllowThreads();
31059 result = ((wxWindow const *)arg1)->GetClientRect();
31060 wxPyEndAllowThreads(__tstate);
31061 if (PyErr_Occurred()) SWIG_fail;
31062 }
31063 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31064 return resultobj;
31065 fail:
31066 return NULL;
31067 }
31068
31069
31070 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31071 PyObject *resultobj = 0;
31072 wxWindow *arg1 = (wxWindow *) 0 ;
31073 wxSize result;
31074 void *argp1 = 0 ;
31075 int res1 = 0 ;
31076 PyObject *swig_obj[1] ;
31077
31078 if (!args) SWIG_fail;
31079 swig_obj[0] = args;
31080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31081 if (!SWIG_IsOK(res1)) {
31082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31083 }
31084 arg1 = reinterpret_cast< wxWindow * >(argp1);
31085 {
31086 PyThreadState* __tstate = wxPyBeginAllowThreads();
31087 result = ((wxWindow const *)arg1)->GetBestSize();
31088 wxPyEndAllowThreads(__tstate);
31089 if (PyErr_Occurred()) SWIG_fail;
31090 }
31091 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31092 return resultobj;
31093 fail:
31094 return NULL;
31095 }
31096
31097
31098 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31099 PyObject *resultobj = 0;
31100 wxWindow *arg1 = (wxWindow *) 0 ;
31101 int *arg2 = (int *) 0 ;
31102 int *arg3 = (int *) 0 ;
31103 void *argp1 = 0 ;
31104 int res1 = 0 ;
31105 int temp2 ;
31106 int res2 = SWIG_TMPOBJ ;
31107 int temp3 ;
31108 int res3 = SWIG_TMPOBJ ;
31109 PyObject *swig_obj[1] ;
31110
31111 arg2 = &temp2;
31112 arg3 = &temp3;
31113 if (!args) SWIG_fail;
31114 swig_obj[0] = args;
31115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31116 if (!SWIG_IsOK(res1)) {
31117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31118 }
31119 arg1 = reinterpret_cast< wxWindow * >(argp1);
31120 {
31121 PyThreadState* __tstate = wxPyBeginAllowThreads();
31122 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31123 wxPyEndAllowThreads(__tstate);
31124 if (PyErr_Occurred()) SWIG_fail;
31125 }
31126 resultobj = SWIG_Py_Void();
31127 if (SWIG_IsTmpObj(res2)) {
31128 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31129 } else {
31130 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31131 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31132 }
31133 if (SWIG_IsTmpObj(res3)) {
31134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31135 } else {
31136 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31137 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31138 }
31139 return resultobj;
31140 fail:
31141 return NULL;
31142 }
31143
31144
31145 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31146 PyObject *resultobj = 0;
31147 wxWindow *arg1 = (wxWindow *) 0 ;
31148 void *argp1 = 0 ;
31149 int res1 = 0 ;
31150 PyObject *swig_obj[1] ;
31151
31152 if (!args) SWIG_fail;
31153 swig_obj[0] = args;
31154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31155 if (!SWIG_IsOK(res1)) {
31156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31157 }
31158 arg1 = reinterpret_cast< wxWindow * >(argp1);
31159 {
31160 PyThreadState* __tstate = wxPyBeginAllowThreads();
31161 (arg1)->InvalidateBestSize();
31162 wxPyEndAllowThreads(__tstate);
31163 if (PyErr_Occurred()) SWIG_fail;
31164 }
31165 resultobj = SWIG_Py_Void();
31166 return resultobj;
31167 fail:
31168 return NULL;
31169 }
31170
31171
31172 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31173 PyObject *resultobj = 0;
31174 wxWindow *arg1 = (wxWindow *) 0 ;
31175 wxSize *arg2 = 0 ;
31176 void *argp1 = 0 ;
31177 int res1 = 0 ;
31178 wxSize temp2 ;
31179 PyObject * obj0 = 0 ;
31180 PyObject * obj1 = 0 ;
31181 char * kwnames[] = {
31182 (char *) "self",(char *) "size", NULL
31183 };
31184
31185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31187 if (!SWIG_IsOK(res1)) {
31188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31189 }
31190 arg1 = reinterpret_cast< wxWindow * >(argp1);
31191 {
31192 arg2 = &temp2;
31193 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31194 }
31195 {
31196 PyThreadState* __tstate = wxPyBeginAllowThreads();
31197 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31198 wxPyEndAllowThreads(__tstate);
31199 if (PyErr_Occurred()) SWIG_fail;
31200 }
31201 resultobj = SWIG_Py_Void();
31202 return resultobj;
31203 fail:
31204 return NULL;
31205 }
31206
31207
31208 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31209 PyObject *resultobj = 0;
31210 wxWindow *arg1 = (wxWindow *) 0 ;
31211 wxSize result;
31212 void *argp1 = 0 ;
31213 int res1 = 0 ;
31214 PyObject *swig_obj[1] ;
31215
31216 if (!args) SWIG_fail;
31217 swig_obj[0] = args;
31218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31219 if (!SWIG_IsOK(res1)) {
31220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31221 }
31222 arg1 = reinterpret_cast< wxWindow * >(argp1);
31223 {
31224 PyThreadState* __tstate = wxPyBeginAllowThreads();
31225 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31226 wxPyEndAllowThreads(__tstate);
31227 if (PyErr_Occurred()) SWIG_fail;
31228 }
31229 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31230 return resultobj;
31231 fail:
31232 return NULL;
31233 }
31234
31235
31236 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31237 PyObject *resultobj = 0;
31238 wxWindow *arg1 = (wxWindow *) 0 ;
31239 wxSize result;
31240 void *argp1 = 0 ;
31241 int res1 = 0 ;
31242 PyObject *swig_obj[1] ;
31243
31244 if (!args) SWIG_fail;
31245 swig_obj[0] = args;
31246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31247 if (!SWIG_IsOK(res1)) {
31248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31249 }
31250 arg1 = reinterpret_cast< wxWindow * >(argp1);
31251 {
31252 PyThreadState* __tstate = wxPyBeginAllowThreads();
31253 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31254 wxPyEndAllowThreads(__tstate);
31255 if (PyErr_Occurred()) SWIG_fail;
31256 }
31257 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31258 return resultobj;
31259 fail:
31260 return NULL;
31261 }
31262
31263
31264 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31265 PyObject *resultobj = 0;
31266 wxWindow *arg1 = (wxWindow *) 0 ;
31267 int arg2 = (int) wxBOTH ;
31268 void *argp1 = 0 ;
31269 int res1 = 0 ;
31270 int val2 ;
31271 int ecode2 = 0 ;
31272 PyObject * obj0 = 0 ;
31273 PyObject * obj1 = 0 ;
31274 char * kwnames[] = {
31275 (char *) "self",(char *) "direction", NULL
31276 };
31277
31278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31280 if (!SWIG_IsOK(res1)) {
31281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31282 }
31283 arg1 = reinterpret_cast< wxWindow * >(argp1);
31284 if (obj1) {
31285 ecode2 = SWIG_AsVal_int(obj1, &val2);
31286 if (!SWIG_IsOK(ecode2)) {
31287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31288 }
31289 arg2 = static_cast< int >(val2);
31290 }
31291 {
31292 PyThreadState* __tstate = wxPyBeginAllowThreads();
31293 (arg1)->Center(arg2);
31294 wxPyEndAllowThreads(__tstate);
31295 if (PyErr_Occurred()) SWIG_fail;
31296 }
31297 resultobj = SWIG_Py_Void();
31298 return resultobj;
31299 fail:
31300 return NULL;
31301 }
31302
31303
31304 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31305 PyObject *resultobj = 0;
31306 wxWindow *arg1 = (wxWindow *) 0 ;
31307 int arg2 = (int) wxBOTH ;
31308 void *argp1 = 0 ;
31309 int res1 = 0 ;
31310 int val2 ;
31311 int ecode2 = 0 ;
31312 PyObject * obj0 = 0 ;
31313 PyObject * obj1 = 0 ;
31314 char * kwnames[] = {
31315 (char *) "self",(char *) "dir", NULL
31316 };
31317
31318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31320 if (!SWIG_IsOK(res1)) {
31321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31322 }
31323 arg1 = reinterpret_cast< wxWindow * >(argp1);
31324 if (obj1) {
31325 ecode2 = SWIG_AsVal_int(obj1, &val2);
31326 if (!SWIG_IsOK(ecode2)) {
31327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31328 }
31329 arg2 = static_cast< int >(val2);
31330 }
31331 {
31332 PyThreadState* __tstate = wxPyBeginAllowThreads();
31333 (arg1)->CenterOnParent(arg2);
31334 wxPyEndAllowThreads(__tstate);
31335 if (PyErr_Occurred()) SWIG_fail;
31336 }
31337 resultobj = SWIG_Py_Void();
31338 return resultobj;
31339 fail:
31340 return NULL;
31341 }
31342
31343
31344 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31345 PyObject *resultobj = 0;
31346 wxWindow *arg1 = (wxWindow *) 0 ;
31347 void *argp1 = 0 ;
31348 int res1 = 0 ;
31349 PyObject *swig_obj[1] ;
31350
31351 if (!args) SWIG_fail;
31352 swig_obj[0] = args;
31353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31354 if (!SWIG_IsOK(res1)) {
31355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31356 }
31357 arg1 = reinterpret_cast< wxWindow * >(argp1);
31358 {
31359 PyThreadState* __tstate = wxPyBeginAllowThreads();
31360 (arg1)->Fit();
31361 wxPyEndAllowThreads(__tstate);
31362 if (PyErr_Occurred()) SWIG_fail;
31363 }
31364 resultobj = SWIG_Py_Void();
31365 return resultobj;
31366 fail:
31367 return NULL;
31368 }
31369
31370
31371 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31372 PyObject *resultobj = 0;
31373 wxWindow *arg1 = (wxWindow *) 0 ;
31374 void *argp1 = 0 ;
31375 int res1 = 0 ;
31376 PyObject *swig_obj[1] ;
31377
31378 if (!args) SWIG_fail;
31379 swig_obj[0] = args;
31380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31381 if (!SWIG_IsOK(res1)) {
31382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31383 }
31384 arg1 = reinterpret_cast< wxWindow * >(argp1);
31385 {
31386 PyThreadState* __tstate = wxPyBeginAllowThreads();
31387 (arg1)->FitInside();
31388 wxPyEndAllowThreads(__tstate);
31389 if (PyErr_Occurred()) SWIG_fail;
31390 }
31391 resultobj = SWIG_Py_Void();
31392 return resultobj;
31393 fail:
31394 return NULL;
31395 }
31396
31397
31398 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31399 PyObject *resultobj = 0;
31400 wxWindow *arg1 = (wxWindow *) 0 ;
31401 int arg2 ;
31402 int arg3 ;
31403 int arg4 = (int) -1 ;
31404 int arg5 = (int) -1 ;
31405 int arg6 = (int) -1 ;
31406 int arg7 = (int) -1 ;
31407 void *argp1 = 0 ;
31408 int res1 = 0 ;
31409 int val2 ;
31410 int ecode2 = 0 ;
31411 int val3 ;
31412 int ecode3 = 0 ;
31413 int val4 ;
31414 int ecode4 = 0 ;
31415 int val5 ;
31416 int ecode5 = 0 ;
31417 int val6 ;
31418 int ecode6 = 0 ;
31419 int val7 ;
31420 int ecode7 = 0 ;
31421 PyObject * obj0 = 0 ;
31422 PyObject * obj1 = 0 ;
31423 PyObject * obj2 = 0 ;
31424 PyObject * obj3 = 0 ;
31425 PyObject * obj4 = 0 ;
31426 PyObject * obj5 = 0 ;
31427 PyObject * obj6 = 0 ;
31428 char * kwnames[] = {
31429 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31430 };
31431
31432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31434 if (!SWIG_IsOK(res1)) {
31435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31436 }
31437 arg1 = reinterpret_cast< wxWindow * >(argp1);
31438 ecode2 = SWIG_AsVal_int(obj1, &val2);
31439 if (!SWIG_IsOK(ecode2)) {
31440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31441 }
31442 arg2 = static_cast< int >(val2);
31443 ecode3 = SWIG_AsVal_int(obj2, &val3);
31444 if (!SWIG_IsOK(ecode3)) {
31445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31446 }
31447 arg3 = static_cast< int >(val3);
31448 if (obj3) {
31449 ecode4 = SWIG_AsVal_int(obj3, &val4);
31450 if (!SWIG_IsOK(ecode4)) {
31451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31452 }
31453 arg4 = static_cast< int >(val4);
31454 }
31455 if (obj4) {
31456 ecode5 = SWIG_AsVal_int(obj4, &val5);
31457 if (!SWIG_IsOK(ecode5)) {
31458 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31459 }
31460 arg5 = static_cast< int >(val5);
31461 }
31462 if (obj5) {
31463 ecode6 = SWIG_AsVal_int(obj5, &val6);
31464 if (!SWIG_IsOK(ecode6)) {
31465 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31466 }
31467 arg6 = static_cast< int >(val6);
31468 }
31469 if (obj6) {
31470 ecode7 = SWIG_AsVal_int(obj6, &val7);
31471 if (!SWIG_IsOK(ecode7)) {
31472 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31473 }
31474 arg7 = static_cast< int >(val7);
31475 }
31476 {
31477 PyThreadState* __tstate = wxPyBeginAllowThreads();
31478 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31479 wxPyEndAllowThreads(__tstate);
31480 if (PyErr_Occurred()) SWIG_fail;
31481 }
31482 resultobj = SWIG_Py_Void();
31483 return resultobj;
31484 fail:
31485 return NULL;
31486 }
31487
31488
31489 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31490 PyObject *resultobj = 0;
31491 wxWindow *arg1 = (wxWindow *) 0 ;
31492 wxSize *arg2 = 0 ;
31493 wxSize const &arg3_defvalue = wxDefaultSize ;
31494 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31495 wxSize const &arg4_defvalue = wxDefaultSize ;
31496 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31497 void *argp1 = 0 ;
31498 int res1 = 0 ;
31499 wxSize temp2 ;
31500 wxSize temp3 ;
31501 wxSize temp4 ;
31502 PyObject * obj0 = 0 ;
31503 PyObject * obj1 = 0 ;
31504 PyObject * obj2 = 0 ;
31505 PyObject * obj3 = 0 ;
31506 char * kwnames[] = {
31507 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31508 };
31509
31510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31512 if (!SWIG_IsOK(res1)) {
31513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31514 }
31515 arg1 = reinterpret_cast< wxWindow * >(argp1);
31516 {
31517 arg2 = &temp2;
31518 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31519 }
31520 if (obj2) {
31521 {
31522 arg3 = &temp3;
31523 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31524 }
31525 }
31526 if (obj3) {
31527 {
31528 arg4 = &temp4;
31529 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31530 }
31531 }
31532 {
31533 PyThreadState* __tstate = wxPyBeginAllowThreads();
31534 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31535 wxPyEndAllowThreads(__tstate);
31536 if (PyErr_Occurred()) SWIG_fail;
31537 }
31538 resultobj = SWIG_Py_Void();
31539 return resultobj;
31540 fail:
31541 return NULL;
31542 }
31543
31544
31545 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31546 PyObject *resultobj = 0;
31547 wxWindow *arg1 = (wxWindow *) 0 ;
31548 int arg2 ;
31549 int arg3 ;
31550 int arg4 = (int) -1 ;
31551 int arg5 = (int) -1 ;
31552 void *argp1 = 0 ;
31553 int res1 = 0 ;
31554 int val2 ;
31555 int ecode2 = 0 ;
31556 int val3 ;
31557 int ecode3 = 0 ;
31558 int val4 ;
31559 int ecode4 = 0 ;
31560 int val5 ;
31561 int ecode5 = 0 ;
31562 PyObject * obj0 = 0 ;
31563 PyObject * obj1 = 0 ;
31564 PyObject * obj2 = 0 ;
31565 PyObject * obj3 = 0 ;
31566 PyObject * obj4 = 0 ;
31567 char * kwnames[] = {
31568 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31569 };
31570
31571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31573 if (!SWIG_IsOK(res1)) {
31574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31575 }
31576 arg1 = reinterpret_cast< wxWindow * >(argp1);
31577 ecode2 = SWIG_AsVal_int(obj1, &val2);
31578 if (!SWIG_IsOK(ecode2)) {
31579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31580 }
31581 arg2 = static_cast< int >(val2);
31582 ecode3 = SWIG_AsVal_int(obj2, &val3);
31583 if (!SWIG_IsOK(ecode3)) {
31584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31585 }
31586 arg3 = static_cast< int >(val3);
31587 if (obj3) {
31588 ecode4 = SWIG_AsVal_int(obj3, &val4);
31589 if (!SWIG_IsOK(ecode4)) {
31590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31591 }
31592 arg4 = static_cast< int >(val4);
31593 }
31594 if (obj4) {
31595 ecode5 = SWIG_AsVal_int(obj4, &val5);
31596 if (!SWIG_IsOK(ecode5)) {
31597 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31598 }
31599 arg5 = static_cast< int >(val5);
31600 }
31601 {
31602 PyThreadState* __tstate = wxPyBeginAllowThreads();
31603 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31604 wxPyEndAllowThreads(__tstate);
31605 if (PyErr_Occurred()) SWIG_fail;
31606 }
31607 resultobj = SWIG_Py_Void();
31608 return resultobj;
31609 fail:
31610 return NULL;
31611 }
31612
31613
31614 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31615 PyObject *resultobj = 0;
31616 wxWindow *arg1 = (wxWindow *) 0 ;
31617 wxSize *arg2 = 0 ;
31618 wxSize const &arg3_defvalue = wxDefaultSize ;
31619 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31620 void *argp1 = 0 ;
31621 int res1 = 0 ;
31622 wxSize temp2 ;
31623 wxSize temp3 ;
31624 PyObject * obj0 = 0 ;
31625 PyObject * obj1 = 0 ;
31626 PyObject * obj2 = 0 ;
31627 char * kwnames[] = {
31628 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31629 };
31630
31631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31633 if (!SWIG_IsOK(res1)) {
31634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31635 }
31636 arg1 = reinterpret_cast< wxWindow * >(argp1);
31637 {
31638 arg2 = &temp2;
31639 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31640 }
31641 if (obj2) {
31642 {
31643 arg3 = &temp3;
31644 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31645 }
31646 }
31647 {
31648 PyThreadState* __tstate = wxPyBeginAllowThreads();
31649 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31650 wxPyEndAllowThreads(__tstate);
31651 if (PyErr_Occurred()) SWIG_fail;
31652 }
31653 resultobj = SWIG_Py_Void();
31654 return resultobj;
31655 fail:
31656 return NULL;
31657 }
31658
31659
31660 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31661 PyObject *resultobj = 0;
31662 wxWindow *arg1 = (wxWindow *) 0 ;
31663 wxSize result;
31664 void *argp1 = 0 ;
31665 int res1 = 0 ;
31666 PyObject *swig_obj[1] ;
31667
31668 if (!args) SWIG_fail;
31669 swig_obj[0] = args;
31670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31671 if (!SWIG_IsOK(res1)) {
31672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31673 }
31674 arg1 = reinterpret_cast< wxWindow * >(argp1);
31675 {
31676 PyThreadState* __tstate = wxPyBeginAllowThreads();
31677 result = ((wxWindow const *)arg1)->GetMaxSize();
31678 wxPyEndAllowThreads(__tstate);
31679 if (PyErr_Occurred()) SWIG_fail;
31680 }
31681 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31682 return resultobj;
31683 fail:
31684 return NULL;
31685 }
31686
31687
31688 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31689 PyObject *resultobj = 0;
31690 wxWindow *arg1 = (wxWindow *) 0 ;
31691 wxSize result;
31692 void *argp1 = 0 ;
31693 int res1 = 0 ;
31694 PyObject *swig_obj[1] ;
31695
31696 if (!args) SWIG_fail;
31697 swig_obj[0] = args;
31698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31699 if (!SWIG_IsOK(res1)) {
31700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31701 }
31702 arg1 = reinterpret_cast< wxWindow * >(argp1);
31703 {
31704 PyThreadState* __tstate = wxPyBeginAllowThreads();
31705 result = ((wxWindow const *)arg1)->GetMinSize();
31706 wxPyEndAllowThreads(__tstate);
31707 if (PyErr_Occurred()) SWIG_fail;
31708 }
31709 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31717 PyObject *resultobj = 0;
31718 wxWindow *arg1 = (wxWindow *) 0 ;
31719 wxSize *arg2 = 0 ;
31720 void *argp1 = 0 ;
31721 int res1 = 0 ;
31722 wxSize temp2 ;
31723 PyObject * obj0 = 0 ;
31724 PyObject * obj1 = 0 ;
31725 char * kwnames[] = {
31726 (char *) "self",(char *) "minSize", NULL
31727 };
31728
31729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31731 if (!SWIG_IsOK(res1)) {
31732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31733 }
31734 arg1 = reinterpret_cast< wxWindow * >(argp1);
31735 {
31736 arg2 = &temp2;
31737 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31738 }
31739 {
31740 PyThreadState* __tstate = wxPyBeginAllowThreads();
31741 (arg1)->SetMinSize((wxSize const &)*arg2);
31742 wxPyEndAllowThreads(__tstate);
31743 if (PyErr_Occurred()) SWIG_fail;
31744 }
31745 resultobj = SWIG_Py_Void();
31746 return resultobj;
31747 fail:
31748 return NULL;
31749 }
31750
31751
31752 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31753 PyObject *resultobj = 0;
31754 wxWindow *arg1 = (wxWindow *) 0 ;
31755 wxSize *arg2 = 0 ;
31756 void *argp1 = 0 ;
31757 int res1 = 0 ;
31758 wxSize temp2 ;
31759 PyObject * obj0 = 0 ;
31760 PyObject * obj1 = 0 ;
31761 char * kwnames[] = {
31762 (char *) "self",(char *) "maxSize", NULL
31763 };
31764
31765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31767 if (!SWIG_IsOK(res1)) {
31768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31769 }
31770 arg1 = reinterpret_cast< wxWindow * >(argp1);
31771 {
31772 arg2 = &temp2;
31773 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31774 }
31775 {
31776 PyThreadState* __tstate = wxPyBeginAllowThreads();
31777 (arg1)->SetMaxSize((wxSize const &)*arg2);
31778 wxPyEndAllowThreads(__tstate);
31779 if (PyErr_Occurred()) SWIG_fail;
31780 }
31781 resultobj = SWIG_Py_Void();
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31789 PyObject *resultobj = 0;
31790 wxWindow *arg1 = (wxWindow *) 0 ;
31791 int result;
31792 void *argp1 = 0 ;
31793 int res1 = 0 ;
31794 PyObject *swig_obj[1] ;
31795
31796 if (!args) SWIG_fail;
31797 swig_obj[0] = args;
31798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31799 if (!SWIG_IsOK(res1)) {
31800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31801 }
31802 arg1 = reinterpret_cast< wxWindow * >(argp1);
31803 {
31804 PyThreadState* __tstate = wxPyBeginAllowThreads();
31805 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31806 wxPyEndAllowThreads(__tstate);
31807 if (PyErr_Occurred()) SWIG_fail;
31808 }
31809 resultobj = SWIG_From_int(static_cast< int >(result));
31810 return resultobj;
31811 fail:
31812 return NULL;
31813 }
31814
31815
31816 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31817 PyObject *resultobj = 0;
31818 wxWindow *arg1 = (wxWindow *) 0 ;
31819 int result;
31820 void *argp1 = 0 ;
31821 int res1 = 0 ;
31822 PyObject *swig_obj[1] ;
31823
31824 if (!args) SWIG_fail;
31825 swig_obj[0] = args;
31826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31827 if (!SWIG_IsOK(res1)) {
31828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31829 }
31830 arg1 = reinterpret_cast< wxWindow * >(argp1);
31831 {
31832 PyThreadState* __tstate = wxPyBeginAllowThreads();
31833 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31834 wxPyEndAllowThreads(__tstate);
31835 if (PyErr_Occurred()) SWIG_fail;
31836 }
31837 resultobj = SWIG_From_int(static_cast< int >(result));
31838 return resultobj;
31839 fail:
31840 return NULL;
31841 }
31842
31843
31844 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31845 PyObject *resultobj = 0;
31846 wxWindow *arg1 = (wxWindow *) 0 ;
31847 int result;
31848 void *argp1 = 0 ;
31849 int res1 = 0 ;
31850 PyObject *swig_obj[1] ;
31851
31852 if (!args) SWIG_fail;
31853 swig_obj[0] = args;
31854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31855 if (!SWIG_IsOK(res1)) {
31856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31857 }
31858 arg1 = reinterpret_cast< wxWindow * >(argp1);
31859 {
31860 PyThreadState* __tstate = wxPyBeginAllowThreads();
31861 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31862 wxPyEndAllowThreads(__tstate);
31863 if (PyErr_Occurred()) SWIG_fail;
31864 }
31865 resultobj = SWIG_From_int(static_cast< int >(result));
31866 return resultobj;
31867 fail:
31868 return NULL;
31869 }
31870
31871
31872 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31873 PyObject *resultobj = 0;
31874 wxWindow *arg1 = (wxWindow *) 0 ;
31875 int result;
31876 void *argp1 = 0 ;
31877 int res1 = 0 ;
31878 PyObject *swig_obj[1] ;
31879
31880 if (!args) SWIG_fail;
31881 swig_obj[0] = args;
31882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31883 if (!SWIG_IsOK(res1)) {
31884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31885 }
31886 arg1 = reinterpret_cast< wxWindow * >(argp1);
31887 {
31888 PyThreadState* __tstate = wxPyBeginAllowThreads();
31889 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31890 wxPyEndAllowThreads(__tstate);
31891 if (PyErr_Occurred()) SWIG_fail;
31892 }
31893 resultobj = SWIG_From_int(static_cast< int >(result));
31894 return resultobj;
31895 fail:
31896 return NULL;
31897 }
31898
31899
31900 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31901 PyObject *resultobj = 0;
31902 wxWindow *arg1 = (wxWindow *) 0 ;
31903 wxSize *arg2 = 0 ;
31904 void *argp1 = 0 ;
31905 int res1 = 0 ;
31906 wxSize temp2 ;
31907 PyObject * obj0 = 0 ;
31908 PyObject * obj1 = 0 ;
31909 char * kwnames[] = {
31910 (char *) "self",(char *) "size", NULL
31911 };
31912
31913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31915 if (!SWIG_IsOK(res1)) {
31916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31917 }
31918 arg1 = reinterpret_cast< wxWindow * >(argp1);
31919 {
31920 arg2 = &temp2;
31921 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31922 }
31923 {
31924 PyThreadState* __tstate = wxPyBeginAllowThreads();
31925 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31926 wxPyEndAllowThreads(__tstate);
31927 if (PyErr_Occurred()) SWIG_fail;
31928 }
31929 resultobj = SWIG_Py_Void();
31930 return resultobj;
31931 fail:
31932 return NULL;
31933 }
31934
31935
31936 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31937 PyObject *resultobj = 0;
31938 wxWindow *arg1 = (wxWindow *) 0 ;
31939 int arg2 ;
31940 int arg3 ;
31941 void *argp1 = 0 ;
31942 int res1 = 0 ;
31943 int val2 ;
31944 int ecode2 = 0 ;
31945 int val3 ;
31946 int ecode3 = 0 ;
31947 PyObject * obj0 = 0 ;
31948 PyObject * obj1 = 0 ;
31949 PyObject * obj2 = 0 ;
31950 char * kwnames[] = {
31951 (char *) "self",(char *) "w",(char *) "h", NULL
31952 };
31953
31954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31956 if (!SWIG_IsOK(res1)) {
31957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31958 }
31959 arg1 = reinterpret_cast< wxWindow * >(argp1);
31960 ecode2 = SWIG_AsVal_int(obj1, &val2);
31961 if (!SWIG_IsOK(ecode2)) {
31962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31963 }
31964 arg2 = static_cast< int >(val2);
31965 ecode3 = SWIG_AsVal_int(obj2, &val3);
31966 if (!SWIG_IsOK(ecode3)) {
31967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31968 }
31969 arg3 = static_cast< int >(val3);
31970 {
31971 PyThreadState* __tstate = wxPyBeginAllowThreads();
31972 (arg1)->SetVirtualSize(arg2,arg3);
31973 wxPyEndAllowThreads(__tstate);
31974 if (PyErr_Occurred()) SWIG_fail;
31975 }
31976 resultobj = SWIG_Py_Void();
31977 return resultobj;
31978 fail:
31979 return NULL;
31980 }
31981
31982
31983 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31984 PyObject *resultobj = 0;
31985 wxWindow *arg1 = (wxWindow *) 0 ;
31986 wxSize result;
31987 void *argp1 = 0 ;
31988 int res1 = 0 ;
31989 PyObject *swig_obj[1] ;
31990
31991 if (!args) SWIG_fail;
31992 swig_obj[0] = args;
31993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31994 if (!SWIG_IsOK(res1)) {
31995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31996 }
31997 arg1 = reinterpret_cast< wxWindow * >(argp1);
31998 {
31999 PyThreadState* __tstate = wxPyBeginAllowThreads();
32000 result = ((wxWindow const *)arg1)->GetVirtualSize();
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32005 return resultobj;
32006 fail:
32007 return NULL;
32008 }
32009
32010
32011 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32012 PyObject *resultobj = 0;
32013 wxWindow *arg1 = (wxWindow *) 0 ;
32014 int *arg2 = (int *) 0 ;
32015 int *arg3 = (int *) 0 ;
32016 void *argp1 = 0 ;
32017 int res1 = 0 ;
32018 int temp2 ;
32019 int res2 = SWIG_TMPOBJ ;
32020 int temp3 ;
32021 int res3 = SWIG_TMPOBJ ;
32022 PyObject *swig_obj[1] ;
32023
32024 arg2 = &temp2;
32025 arg3 = &temp3;
32026 if (!args) SWIG_fail;
32027 swig_obj[0] = args;
32028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32029 if (!SWIG_IsOK(res1)) {
32030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32031 }
32032 arg1 = reinterpret_cast< wxWindow * >(argp1);
32033 {
32034 PyThreadState* __tstate = wxPyBeginAllowThreads();
32035 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32036 wxPyEndAllowThreads(__tstate);
32037 if (PyErr_Occurred()) SWIG_fail;
32038 }
32039 resultobj = SWIG_Py_Void();
32040 if (SWIG_IsTmpObj(res2)) {
32041 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32042 } else {
32043 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32044 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32045 }
32046 if (SWIG_IsTmpObj(res3)) {
32047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32048 } else {
32049 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32050 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32051 }
32052 return resultobj;
32053 fail:
32054 return NULL;
32055 }
32056
32057
32058 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32059 PyObject *resultobj = 0;
32060 wxWindow *arg1 = (wxWindow *) 0 ;
32061 wxSize result;
32062 void *argp1 = 0 ;
32063 int res1 = 0 ;
32064 PyObject *swig_obj[1] ;
32065
32066 if (!args) SWIG_fail;
32067 swig_obj[0] = args;
32068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32069 if (!SWIG_IsOK(res1)) {
32070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32071 }
32072 arg1 = reinterpret_cast< wxWindow * >(argp1);
32073 {
32074 PyThreadState* __tstate = wxPyBeginAllowThreads();
32075 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32076 wxPyEndAllowThreads(__tstate);
32077 if (PyErr_Occurred()) SWIG_fail;
32078 }
32079 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32080 return resultobj;
32081 fail:
32082 return NULL;
32083 }
32084
32085
32086 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32087 PyObject *resultobj = 0;
32088 wxWindow *arg1 = (wxWindow *) 0 ;
32089 bool arg2 = (bool) true ;
32090 bool result;
32091 void *argp1 = 0 ;
32092 int res1 = 0 ;
32093 bool val2 ;
32094 int ecode2 = 0 ;
32095 PyObject * obj0 = 0 ;
32096 PyObject * obj1 = 0 ;
32097 char * kwnames[] = {
32098 (char *) "self",(char *) "show", NULL
32099 };
32100
32101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32103 if (!SWIG_IsOK(res1)) {
32104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32105 }
32106 arg1 = reinterpret_cast< wxWindow * >(argp1);
32107 if (obj1) {
32108 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32109 if (!SWIG_IsOK(ecode2)) {
32110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32111 }
32112 arg2 = static_cast< bool >(val2);
32113 }
32114 {
32115 PyThreadState* __tstate = wxPyBeginAllowThreads();
32116 result = (bool)(arg1)->Show(arg2);
32117 wxPyEndAllowThreads(__tstate);
32118 if (PyErr_Occurred()) SWIG_fail;
32119 }
32120 {
32121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32122 }
32123 return resultobj;
32124 fail:
32125 return NULL;
32126 }
32127
32128
32129 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32130 PyObject *resultobj = 0;
32131 wxWindow *arg1 = (wxWindow *) 0 ;
32132 bool result;
32133 void *argp1 = 0 ;
32134 int res1 = 0 ;
32135 PyObject *swig_obj[1] ;
32136
32137 if (!args) SWIG_fail;
32138 swig_obj[0] = args;
32139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32140 if (!SWIG_IsOK(res1)) {
32141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32142 }
32143 arg1 = reinterpret_cast< wxWindow * >(argp1);
32144 {
32145 PyThreadState* __tstate = wxPyBeginAllowThreads();
32146 result = (bool)(arg1)->Hide();
32147 wxPyEndAllowThreads(__tstate);
32148 if (PyErr_Occurred()) SWIG_fail;
32149 }
32150 {
32151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32152 }
32153 return resultobj;
32154 fail:
32155 return NULL;
32156 }
32157
32158
32159 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32160 PyObject *resultobj = 0;
32161 wxWindow *arg1 = (wxWindow *) 0 ;
32162 bool arg2 = (bool) true ;
32163 bool result;
32164 void *argp1 = 0 ;
32165 int res1 = 0 ;
32166 bool val2 ;
32167 int ecode2 = 0 ;
32168 PyObject * obj0 = 0 ;
32169 PyObject * obj1 = 0 ;
32170 char * kwnames[] = {
32171 (char *) "self",(char *) "enable", NULL
32172 };
32173
32174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32176 if (!SWIG_IsOK(res1)) {
32177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32178 }
32179 arg1 = reinterpret_cast< wxWindow * >(argp1);
32180 if (obj1) {
32181 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32182 if (!SWIG_IsOK(ecode2)) {
32183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32184 }
32185 arg2 = static_cast< bool >(val2);
32186 }
32187 {
32188 PyThreadState* __tstate = wxPyBeginAllowThreads();
32189 result = (bool)(arg1)->Enable(arg2);
32190 wxPyEndAllowThreads(__tstate);
32191 if (PyErr_Occurred()) SWIG_fail;
32192 }
32193 {
32194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32195 }
32196 return resultobj;
32197 fail:
32198 return NULL;
32199 }
32200
32201
32202 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32203 PyObject *resultobj = 0;
32204 wxWindow *arg1 = (wxWindow *) 0 ;
32205 bool result;
32206 void *argp1 = 0 ;
32207 int res1 = 0 ;
32208 PyObject *swig_obj[1] ;
32209
32210 if (!args) SWIG_fail;
32211 swig_obj[0] = args;
32212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32213 if (!SWIG_IsOK(res1)) {
32214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32215 }
32216 arg1 = reinterpret_cast< wxWindow * >(argp1);
32217 {
32218 PyThreadState* __tstate = wxPyBeginAllowThreads();
32219 result = (bool)(arg1)->Disable();
32220 wxPyEndAllowThreads(__tstate);
32221 if (PyErr_Occurred()) SWIG_fail;
32222 }
32223 {
32224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32225 }
32226 return resultobj;
32227 fail:
32228 return NULL;
32229 }
32230
32231
32232 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32233 PyObject *resultobj = 0;
32234 wxWindow *arg1 = (wxWindow *) 0 ;
32235 bool result;
32236 void *argp1 = 0 ;
32237 int res1 = 0 ;
32238 PyObject *swig_obj[1] ;
32239
32240 if (!args) SWIG_fail;
32241 swig_obj[0] = args;
32242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32243 if (!SWIG_IsOK(res1)) {
32244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32245 }
32246 arg1 = reinterpret_cast< wxWindow * >(argp1);
32247 {
32248 PyThreadState* __tstate = wxPyBeginAllowThreads();
32249 result = (bool)((wxWindow const *)arg1)->IsShown();
32250 wxPyEndAllowThreads(__tstate);
32251 if (PyErr_Occurred()) SWIG_fail;
32252 }
32253 {
32254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32255 }
32256 return resultobj;
32257 fail:
32258 return NULL;
32259 }
32260
32261
32262 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32263 PyObject *resultobj = 0;
32264 wxWindow *arg1 = (wxWindow *) 0 ;
32265 bool result;
32266 void *argp1 = 0 ;
32267 int res1 = 0 ;
32268 PyObject *swig_obj[1] ;
32269
32270 if (!args) SWIG_fail;
32271 swig_obj[0] = args;
32272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32273 if (!SWIG_IsOK(res1)) {
32274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32275 }
32276 arg1 = reinterpret_cast< wxWindow * >(argp1);
32277 {
32278 PyThreadState* __tstate = wxPyBeginAllowThreads();
32279 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32280 wxPyEndAllowThreads(__tstate);
32281 if (PyErr_Occurred()) SWIG_fail;
32282 }
32283 {
32284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32285 }
32286 return resultobj;
32287 fail:
32288 return NULL;
32289 }
32290
32291
32292 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32293 PyObject *resultobj = 0;
32294 wxWindow *arg1 = (wxWindow *) 0 ;
32295 long arg2 ;
32296 void *argp1 = 0 ;
32297 int res1 = 0 ;
32298 long val2 ;
32299 int ecode2 = 0 ;
32300 PyObject * obj0 = 0 ;
32301 PyObject * obj1 = 0 ;
32302 char * kwnames[] = {
32303 (char *) "self",(char *) "style", NULL
32304 };
32305
32306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32308 if (!SWIG_IsOK(res1)) {
32309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32310 }
32311 arg1 = reinterpret_cast< wxWindow * >(argp1);
32312 ecode2 = SWIG_AsVal_long(obj1, &val2);
32313 if (!SWIG_IsOK(ecode2)) {
32314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32315 }
32316 arg2 = static_cast< long >(val2);
32317 {
32318 PyThreadState* __tstate = wxPyBeginAllowThreads();
32319 (arg1)->SetWindowStyleFlag(arg2);
32320 wxPyEndAllowThreads(__tstate);
32321 if (PyErr_Occurred()) SWIG_fail;
32322 }
32323 resultobj = SWIG_Py_Void();
32324 return resultobj;
32325 fail:
32326 return NULL;
32327 }
32328
32329
32330 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32331 PyObject *resultobj = 0;
32332 wxWindow *arg1 = (wxWindow *) 0 ;
32333 long result;
32334 void *argp1 = 0 ;
32335 int res1 = 0 ;
32336 PyObject *swig_obj[1] ;
32337
32338 if (!args) SWIG_fail;
32339 swig_obj[0] = args;
32340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32341 if (!SWIG_IsOK(res1)) {
32342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32343 }
32344 arg1 = reinterpret_cast< wxWindow * >(argp1);
32345 {
32346 PyThreadState* __tstate = wxPyBeginAllowThreads();
32347 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32348 wxPyEndAllowThreads(__tstate);
32349 if (PyErr_Occurred()) SWIG_fail;
32350 }
32351 resultobj = SWIG_From_long(static_cast< long >(result));
32352 return resultobj;
32353 fail:
32354 return NULL;
32355 }
32356
32357
32358 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32359 PyObject *resultobj = 0;
32360 wxWindow *arg1 = (wxWindow *) 0 ;
32361 int arg2 ;
32362 bool result;
32363 void *argp1 = 0 ;
32364 int res1 = 0 ;
32365 int val2 ;
32366 int ecode2 = 0 ;
32367 PyObject * obj0 = 0 ;
32368 PyObject * obj1 = 0 ;
32369 char * kwnames[] = {
32370 (char *) "self",(char *) "flag", NULL
32371 };
32372
32373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32375 if (!SWIG_IsOK(res1)) {
32376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32377 }
32378 arg1 = reinterpret_cast< wxWindow * >(argp1);
32379 ecode2 = SWIG_AsVal_int(obj1, &val2);
32380 if (!SWIG_IsOK(ecode2)) {
32381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32382 }
32383 arg2 = static_cast< int >(val2);
32384 {
32385 PyThreadState* __tstate = wxPyBeginAllowThreads();
32386 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32387 wxPyEndAllowThreads(__tstate);
32388 if (PyErr_Occurred()) SWIG_fail;
32389 }
32390 {
32391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32392 }
32393 return resultobj;
32394 fail:
32395 return NULL;
32396 }
32397
32398
32399 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32400 PyObject *resultobj = 0;
32401 wxWindow *arg1 = (wxWindow *) 0 ;
32402 bool result;
32403 void *argp1 = 0 ;
32404 int res1 = 0 ;
32405 PyObject *swig_obj[1] ;
32406
32407 if (!args) SWIG_fail;
32408 swig_obj[0] = args;
32409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32410 if (!SWIG_IsOK(res1)) {
32411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32412 }
32413 arg1 = reinterpret_cast< wxWindow * >(argp1);
32414 {
32415 PyThreadState* __tstate = wxPyBeginAllowThreads();
32416 result = (bool)((wxWindow const *)arg1)->IsRetained();
32417 wxPyEndAllowThreads(__tstate);
32418 if (PyErr_Occurred()) SWIG_fail;
32419 }
32420 {
32421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32422 }
32423 return resultobj;
32424 fail:
32425 return NULL;
32426 }
32427
32428
32429 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32430 PyObject *resultobj = 0;
32431 wxWindow *arg1 = (wxWindow *) 0 ;
32432 long arg2 ;
32433 void *argp1 = 0 ;
32434 int res1 = 0 ;
32435 long val2 ;
32436 int ecode2 = 0 ;
32437 PyObject * obj0 = 0 ;
32438 PyObject * obj1 = 0 ;
32439 char * kwnames[] = {
32440 (char *) "self",(char *) "exStyle", NULL
32441 };
32442
32443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32445 if (!SWIG_IsOK(res1)) {
32446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32447 }
32448 arg1 = reinterpret_cast< wxWindow * >(argp1);
32449 ecode2 = SWIG_AsVal_long(obj1, &val2);
32450 if (!SWIG_IsOK(ecode2)) {
32451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32452 }
32453 arg2 = static_cast< long >(val2);
32454 {
32455 PyThreadState* __tstate = wxPyBeginAllowThreads();
32456 (arg1)->SetExtraStyle(arg2);
32457 wxPyEndAllowThreads(__tstate);
32458 if (PyErr_Occurred()) SWIG_fail;
32459 }
32460 resultobj = SWIG_Py_Void();
32461 return resultobj;
32462 fail:
32463 return NULL;
32464 }
32465
32466
32467 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32468 PyObject *resultobj = 0;
32469 wxWindow *arg1 = (wxWindow *) 0 ;
32470 long result;
32471 void *argp1 = 0 ;
32472 int res1 = 0 ;
32473 PyObject *swig_obj[1] ;
32474
32475 if (!args) SWIG_fail;
32476 swig_obj[0] = args;
32477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32478 if (!SWIG_IsOK(res1)) {
32479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32480 }
32481 arg1 = reinterpret_cast< wxWindow * >(argp1);
32482 {
32483 PyThreadState* __tstate = wxPyBeginAllowThreads();
32484 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32485 wxPyEndAllowThreads(__tstate);
32486 if (PyErr_Occurred()) SWIG_fail;
32487 }
32488 resultobj = SWIG_From_long(static_cast< long >(result));
32489 return resultobj;
32490 fail:
32491 return NULL;
32492 }
32493
32494
32495 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32496 PyObject *resultobj = 0;
32497 wxWindow *arg1 = (wxWindow *) 0 ;
32498 bool arg2 = (bool) true ;
32499 void *argp1 = 0 ;
32500 int res1 = 0 ;
32501 bool val2 ;
32502 int ecode2 = 0 ;
32503 PyObject * obj0 = 0 ;
32504 PyObject * obj1 = 0 ;
32505 char * kwnames[] = {
32506 (char *) "self",(char *) "modal", NULL
32507 };
32508
32509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32511 if (!SWIG_IsOK(res1)) {
32512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32513 }
32514 arg1 = reinterpret_cast< wxWindow * >(argp1);
32515 if (obj1) {
32516 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32517 if (!SWIG_IsOK(ecode2)) {
32518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32519 }
32520 arg2 = static_cast< bool >(val2);
32521 }
32522 {
32523 PyThreadState* __tstate = wxPyBeginAllowThreads();
32524 (arg1)->MakeModal(arg2);
32525 wxPyEndAllowThreads(__tstate);
32526 if (PyErr_Occurred()) SWIG_fail;
32527 }
32528 resultobj = SWIG_Py_Void();
32529 return resultobj;
32530 fail:
32531 return NULL;
32532 }
32533
32534
32535 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32536 PyObject *resultobj = 0;
32537 wxWindow *arg1 = (wxWindow *) 0 ;
32538 bool arg2 ;
32539 void *argp1 = 0 ;
32540 int res1 = 0 ;
32541 bool val2 ;
32542 int ecode2 = 0 ;
32543 PyObject * obj0 = 0 ;
32544 PyObject * obj1 = 0 ;
32545 char * kwnames[] = {
32546 (char *) "self",(char *) "enableTheme", NULL
32547 };
32548
32549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32551 if (!SWIG_IsOK(res1)) {
32552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32553 }
32554 arg1 = reinterpret_cast< wxWindow * >(argp1);
32555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32556 if (!SWIG_IsOK(ecode2)) {
32557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32558 }
32559 arg2 = static_cast< bool >(val2);
32560 {
32561 PyThreadState* __tstate = wxPyBeginAllowThreads();
32562 (arg1)->SetThemeEnabled(arg2);
32563 wxPyEndAllowThreads(__tstate);
32564 if (PyErr_Occurred()) SWIG_fail;
32565 }
32566 resultobj = SWIG_Py_Void();
32567 return resultobj;
32568 fail:
32569 return NULL;
32570 }
32571
32572
32573 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32574 PyObject *resultobj = 0;
32575 wxWindow *arg1 = (wxWindow *) 0 ;
32576 bool result;
32577 void *argp1 = 0 ;
32578 int res1 = 0 ;
32579 PyObject *swig_obj[1] ;
32580
32581 if (!args) SWIG_fail;
32582 swig_obj[0] = args;
32583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32584 if (!SWIG_IsOK(res1)) {
32585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32586 }
32587 arg1 = reinterpret_cast< wxWindow * >(argp1);
32588 {
32589 PyThreadState* __tstate = wxPyBeginAllowThreads();
32590 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32591 wxPyEndAllowThreads(__tstate);
32592 if (PyErr_Occurred()) SWIG_fail;
32593 }
32594 {
32595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32596 }
32597 return resultobj;
32598 fail:
32599 return NULL;
32600 }
32601
32602
32603 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32604 PyObject *resultobj = 0;
32605 wxWindow *arg1 = (wxWindow *) 0 ;
32606 void *argp1 = 0 ;
32607 int res1 = 0 ;
32608 PyObject *swig_obj[1] ;
32609
32610 if (!args) SWIG_fail;
32611 swig_obj[0] = args;
32612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32613 if (!SWIG_IsOK(res1)) {
32614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32615 }
32616 arg1 = reinterpret_cast< wxWindow * >(argp1);
32617 {
32618 PyThreadState* __tstate = wxPyBeginAllowThreads();
32619 (arg1)->SetFocus();
32620 wxPyEndAllowThreads(__tstate);
32621 if (PyErr_Occurred()) SWIG_fail;
32622 }
32623 resultobj = SWIG_Py_Void();
32624 return resultobj;
32625 fail:
32626 return NULL;
32627 }
32628
32629
32630 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32631 PyObject *resultobj = 0;
32632 wxWindow *arg1 = (wxWindow *) 0 ;
32633 void *argp1 = 0 ;
32634 int res1 = 0 ;
32635 PyObject *swig_obj[1] ;
32636
32637 if (!args) SWIG_fail;
32638 swig_obj[0] = args;
32639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32640 if (!SWIG_IsOK(res1)) {
32641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32642 }
32643 arg1 = reinterpret_cast< wxWindow * >(argp1);
32644 {
32645 PyThreadState* __tstate = wxPyBeginAllowThreads();
32646 (arg1)->SetFocusFromKbd();
32647 wxPyEndAllowThreads(__tstate);
32648 if (PyErr_Occurred()) SWIG_fail;
32649 }
32650 resultobj = SWIG_Py_Void();
32651 return resultobj;
32652 fail:
32653 return NULL;
32654 }
32655
32656
32657 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32658 PyObject *resultobj = 0;
32659 wxWindow *result = 0 ;
32660
32661 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32662 {
32663 if (!wxPyCheckForApp()) SWIG_fail;
32664 PyThreadState* __tstate = wxPyBeginAllowThreads();
32665 result = (wxWindow *)wxWindow::FindFocus();
32666 wxPyEndAllowThreads(__tstate);
32667 if (PyErr_Occurred()) SWIG_fail;
32668 }
32669 {
32670 resultobj = wxPyMake_wxObject(result, 0);
32671 }
32672 return resultobj;
32673 fail:
32674 return NULL;
32675 }
32676
32677
32678 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32679 PyObject *resultobj = 0;
32680 wxWindow *arg1 = (wxWindow *) 0 ;
32681 bool result;
32682 void *argp1 = 0 ;
32683 int res1 = 0 ;
32684 PyObject *swig_obj[1] ;
32685
32686 if (!args) SWIG_fail;
32687 swig_obj[0] = args;
32688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32689 if (!SWIG_IsOK(res1)) {
32690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32691 }
32692 arg1 = reinterpret_cast< wxWindow * >(argp1);
32693 {
32694 PyThreadState* __tstate = wxPyBeginAllowThreads();
32695 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32696 wxPyEndAllowThreads(__tstate);
32697 if (PyErr_Occurred()) SWIG_fail;
32698 }
32699 {
32700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32701 }
32702 return resultobj;
32703 fail:
32704 return NULL;
32705 }
32706
32707
32708 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32709 PyObject *resultobj = 0;
32710 wxWindow *arg1 = (wxWindow *) 0 ;
32711 bool result;
32712 void *argp1 = 0 ;
32713 int res1 = 0 ;
32714 PyObject *swig_obj[1] ;
32715
32716 if (!args) SWIG_fail;
32717 swig_obj[0] = args;
32718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32719 if (!SWIG_IsOK(res1)) {
32720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32721 }
32722 arg1 = reinterpret_cast< wxWindow * >(argp1);
32723 {
32724 PyThreadState* __tstate = wxPyBeginAllowThreads();
32725 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32726 wxPyEndAllowThreads(__tstate);
32727 if (PyErr_Occurred()) SWIG_fail;
32728 }
32729 {
32730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32731 }
32732 return resultobj;
32733 fail:
32734 return NULL;
32735 }
32736
32737
32738 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32739 PyObject *resultobj = 0;
32740 wxWindow *arg1 = (wxWindow *) 0 ;
32741 wxWindow *result = 0 ;
32742 void *argp1 = 0 ;
32743 int res1 = 0 ;
32744 PyObject *swig_obj[1] ;
32745
32746 if (!args) SWIG_fail;
32747 swig_obj[0] = args;
32748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32749 if (!SWIG_IsOK(res1)) {
32750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32751 }
32752 arg1 = reinterpret_cast< wxWindow * >(argp1);
32753 {
32754 PyThreadState* __tstate = wxPyBeginAllowThreads();
32755 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32756 wxPyEndAllowThreads(__tstate);
32757 if (PyErr_Occurred()) SWIG_fail;
32758 }
32759 {
32760 resultobj = wxPyMake_wxObject(result, 0);
32761 }
32762 return resultobj;
32763 fail:
32764 return NULL;
32765 }
32766
32767
32768 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32769 PyObject *resultobj = 0;
32770 wxWindow *arg1 = (wxWindow *) 0 ;
32771 wxWindow *arg2 = (wxWindow *) 0 ;
32772 wxWindow *result = 0 ;
32773 void *argp1 = 0 ;
32774 int res1 = 0 ;
32775 void *argp2 = 0 ;
32776 int res2 = 0 ;
32777 PyObject * obj0 = 0 ;
32778 PyObject * obj1 = 0 ;
32779 char * kwnames[] = {
32780 (char *) "self",(char *) "child", NULL
32781 };
32782
32783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32785 if (!SWIG_IsOK(res1)) {
32786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32787 }
32788 arg1 = reinterpret_cast< wxWindow * >(argp1);
32789 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32790 if (!SWIG_IsOK(res2)) {
32791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32792 }
32793 arg2 = reinterpret_cast< wxWindow * >(argp2);
32794 {
32795 PyThreadState* __tstate = wxPyBeginAllowThreads();
32796 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32797 wxPyEndAllowThreads(__tstate);
32798 if (PyErr_Occurred()) SWIG_fail;
32799 }
32800 {
32801 resultobj = wxPyMake_wxObject(result, 0);
32802 }
32803 return resultobj;
32804 fail:
32805 return NULL;
32806 }
32807
32808
32809 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32810 PyObject *resultobj = 0;
32811 wxWindow *arg1 = (wxWindow *) 0 ;
32812 wxWindow *arg2 = (wxWindow *) 0 ;
32813 void *argp1 = 0 ;
32814 int res1 = 0 ;
32815 void *argp2 = 0 ;
32816 int res2 = 0 ;
32817 PyObject * obj0 = 0 ;
32818 PyObject * obj1 = 0 ;
32819 char * kwnames[] = {
32820 (char *) "self",(char *) "win", NULL
32821 };
32822
32823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32825 if (!SWIG_IsOK(res1)) {
32826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32827 }
32828 arg1 = reinterpret_cast< wxWindow * >(argp1);
32829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32830 if (!SWIG_IsOK(res2)) {
32831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32832 }
32833 arg2 = reinterpret_cast< wxWindow * >(argp2);
32834 {
32835 PyThreadState* __tstate = wxPyBeginAllowThreads();
32836 (arg1)->SetTmpDefaultItem(arg2);
32837 wxPyEndAllowThreads(__tstate);
32838 if (PyErr_Occurred()) SWIG_fail;
32839 }
32840 resultobj = SWIG_Py_Void();
32841 return resultobj;
32842 fail:
32843 return NULL;
32844 }
32845
32846
32847 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32848 PyObject *resultobj = 0;
32849 wxWindow *arg1 = (wxWindow *) 0 ;
32850 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32851 bool result;
32852 void *argp1 = 0 ;
32853 int res1 = 0 ;
32854 int val2 ;
32855 int ecode2 = 0 ;
32856 PyObject * obj0 = 0 ;
32857 PyObject * obj1 = 0 ;
32858 char * kwnames[] = {
32859 (char *) "self",(char *) "flags", NULL
32860 };
32861
32862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32864 if (!SWIG_IsOK(res1)) {
32865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32866 }
32867 arg1 = reinterpret_cast< wxWindow * >(argp1);
32868 if (obj1) {
32869 ecode2 = SWIG_AsVal_int(obj1, &val2);
32870 if (!SWIG_IsOK(ecode2)) {
32871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32872 }
32873 arg2 = static_cast< int >(val2);
32874 }
32875 {
32876 PyThreadState* __tstate = wxPyBeginAllowThreads();
32877 result = (bool)(arg1)->Navigate(arg2);
32878 wxPyEndAllowThreads(__tstate);
32879 if (PyErr_Occurred()) SWIG_fail;
32880 }
32881 {
32882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32883 }
32884 return resultobj;
32885 fail:
32886 return NULL;
32887 }
32888
32889
32890 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32891 PyObject *resultobj = 0;
32892 wxWindow *arg1 = (wxWindow *) 0 ;
32893 wxWindow *arg2 = (wxWindow *) 0 ;
32894 void *argp1 = 0 ;
32895 int res1 = 0 ;
32896 void *argp2 = 0 ;
32897 int res2 = 0 ;
32898 PyObject * obj0 = 0 ;
32899 PyObject * obj1 = 0 ;
32900 char * kwnames[] = {
32901 (char *) "self",(char *) "win", NULL
32902 };
32903
32904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32906 if (!SWIG_IsOK(res1)) {
32907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32908 }
32909 arg1 = reinterpret_cast< wxWindow * >(argp1);
32910 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32911 if (!SWIG_IsOK(res2)) {
32912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32913 }
32914 arg2 = reinterpret_cast< wxWindow * >(argp2);
32915 {
32916 PyThreadState* __tstate = wxPyBeginAllowThreads();
32917 (arg1)->MoveAfterInTabOrder(arg2);
32918 wxPyEndAllowThreads(__tstate);
32919 if (PyErr_Occurred()) SWIG_fail;
32920 }
32921 resultobj = SWIG_Py_Void();
32922 return resultobj;
32923 fail:
32924 return NULL;
32925 }
32926
32927
32928 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32929 PyObject *resultobj = 0;
32930 wxWindow *arg1 = (wxWindow *) 0 ;
32931 wxWindow *arg2 = (wxWindow *) 0 ;
32932 void *argp1 = 0 ;
32933 int res1 = 0 ;
32934 void *argp2 = 0 ;
32935 int res2 = 0 ;
32936 PyObject * obj0 = 0 ;
32937 PyObject * obj1 = 0 ;
32938 char * kwnames[] = {
32939 (char *) "self",(char *) "win", NULL
32940 };
32941
32942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32944 if (!SWIG_IsOK(res1)) {
32945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32946 }
32947 arg1 = reinterpret_cast< wxWindow * >(argp1);
32948 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32949 if (!SWIG_IsOK(res2)) {
32950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32951 }
32952 arg2 = reinterpret_cast< wxWindow * >(argp2);
32953 {
32954 PyThreadState* __tstate = wxPyBeginAllowThreads();
32955 (arg1)->MoveBeforeInTabOrder(arg2);
32956 wxPyEndAllowThreads(__tstate);
32957 if (PyErr_Occurred()) SWIG_fail;
32958 }
32959 resultobj = SWIG_Py_Void();
32960 return resultobj;
32961 fail:
32962 return NULL;
32963 }
32964
32965
32966 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32967 PyObject *resultobj = 0;
32968 wxWindow *arg1 = (wxWindow *) 0 ;
32969 PyObject *result = 0 ;
32970 void *argp1 = 0 ;
32971 int res1 = 0 ;
32972 PyObject *swig_obj[1] ;
32973
32974 if (!args) SWIG_fail;
32975 swig_obj[0] = args;
32976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32977 if (!SWIG_IsOK(res1)) {
32978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32979 }
32980 arg1 = reinterpret_cast< wxWindow * >(argp1);
32981 {
32982 PyThreadState* __tstate = wxPyBeginAllowThreads();
32983 result = (PyObject *)wxWindow_GetChildren(arg1);
32984 wxPyEndAllowThreads(__tstate);
32985 if (PyErr_Occurred()) SWIG_fail;
32986 }
32987 resultobj = result;
32988 return resultobj;
32989 fail:
32990 return NULL;
32991 }
32992
32993
32994 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32995 PyObject *resultobj = 0;
32996 wxWindow *arg1 = (wxWindow *) 0 ;
32997 wxWindow *result = 0 ;
32998 void *argp1 = 0 ;
32999 int res1 = 0 ;
33000 PyObject *swig_obj[1] ;
33001
33002 if (!args) SWIG_fail;
33003 swig_obj[0] = args;
33004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33005 if (!SWIG_IsOK(res1)) {
33006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33007 }
33008 arg1 = reinterpret_cast< wxWindow * >(argp1);
33009 {
33010 PyThreadState* __tstate = wxPyBeginAllowThreads();
33011 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33012 wxPyEndAllowThreads(__tstate);
33013 if (PyErr_Occurred()) SWIG_fail;
33014 }
33015 {
33016 resultobj = wxPyMake_wxObject(result, 0);
33017 }
33018 return resultobj;
33019 fail:
33020 return NULL;
33021 }
33022
33023
33024 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33025 PyObject *resultobj = 0;
33026 wxWindow *arg1 = (wxWindow *) 0 ;
33027 wxWindow *result = 0 ;
33028 void *argp1 = 0 ;
33029 int res1 = 0 ;
33030 PyObject *swig_obj[1] ;
33031
33032 if (!args) SWIG_fail;
33033 swig_obj[0] = args;
33034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33035 if (!SWIG_IsOK(res1)) {
33036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33037 }
33038 arg1 = reinterpret_cast< wxWindow * >(argp1);
33039 {
33040 PyThreadState* __tstate = wxPyBeginAllowThreads();
33041 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33042 wxPyEndAllowThreads(__tstate);
33043 if (PyErr_Occurred()) SWIG_fail;
33044 }
33045 {
33046 resultobj = wxPyMake_wxObject(result, 0);
33047 }
33048 return resultobj;
33049 fail:
33050 return NULL;
33051 }
33052
33053
33054 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33055 PyObject *resultobj = 0;
33056 wxWindow *arg1 = (wxWindow *) 0 ;
33057 bool result;
33058 void *argp1 = 0 ;
33059 int res1 = 0 ;
33060 PyObject *swig_obj[1] ;
33061
33062 if (!args) SWIG_fail;
33063 swig_obj[0] = args;
33064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33065 if (!SWIG_IsOK(res1)) {
33066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33067 }
33068 arg1 = reinterpret_cast< wxWindow * >(argp1);
33069 {
33070 PyThreadState* __tstate = wxPyBeginAllowThreads();
33071 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33072 wxPyEndAllowThreads(__tstate);
33073 if (PyErr_Occurred()) SWIG_fail;
33074 }
33075 {
33076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33077 }
33078 return resultobj;
33079 fail:
33080 return NULL;
33081 }
33082
33083
33084 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33085 PyObject *resultobj = 0;
33086 wxWindow *arg1 = (wxWindow *) 0 ;
33087 wxWindow *arg2 = (wxWindow *) 0 ;
33088 bool result;
33089 void *argp1 = 0 ;
33090 int res1 = 0 ;
33091 void *argp2 = 0 ;
33092 int res2 = 0 ;
33093 PyObject * obj0 = 0 ;
33094 PyObject * obj1 = 0 ;
33095 char * kwnames[] = {
33096 (char *) "self",(char *) "newParent", NULL
33097 };
33098
33099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33101 if (!SWIG_IsOK(res1)) {
33102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33103 }
33104 arg1 = reinterpret_cast< wxWindow * >(argp1);
33105 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33106 if (!SWIG_IsOK(res2)) {
33107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33108 }
33109 arg2 = reinterpret_cast< wxWindow * >(argp2);
33110 {
33111 PyThreadState* __tstate = wxPyBeginAllowThreads();
33112 result = (bool)(arg1)->Reparent(arg2);
33113 wxPyEndAllowThreads(__tstate);
33114 if (PyErr_Occurred()) SWIG_fail;
33115 }
33116 {
33117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33118 }
33119 return resultobj;
33120 fail:
33121 return NULL;
33122 }
33123
33124
33125 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33126 PyObject *resultobj = 0;
33127 wxWindow *arg1 = (wxWindow *) 0 ;
33128 wxWindow *arg2 = (wxWindow *) 0 ;
33129 void *argp1 = 0 ;
33130 int res1 = 0 ;
33131 void *argp2 = 0 ;
33132 int res2 = 0 ;
33133 PyObject * obj0 = 0 ;
33134 PyObject * obj1 = 0 ;
33135 char * kwnames[] = {
33136 (char *) "self",(char *) "child", NULL
33137 };
33138
33139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33141 if (!SWIG_IsOK(res1)) {
33142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33143 }
33144 arg1 = reinterpret_cast< wxWindow * >(argp1);
33145 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33146 if (!SWIG_IsOK(res2)) {
33147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33148 }
33149 arg2 = reinterpret_cast< wxWindow * >(argp2);
33150 {
33151 PyThreadState* __tstate = wxPyBeginAllowThreads();
33152 (arg1)->AddChild(arg2);
33153 wxPyEndAllowThreads(__tstate);
33154 if (PyErr_Occurred()) SWIG_fail;
33155 }
33156 resultobj = SWIG_Py_Void();
33157 return resultobj;
33158 fail:
33159 return NULL;
33160 }
33161
33162
33163 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33164 PyObject *resultobj = 0;
33165 wxWindow *arg1 = (wxWindow *) 0 ;
33166 wxWindow *arg2 = (wxWindow *) 0 ;
33167 void *argp1 = 0 ;
33168 int res1 = 0 ;
33169 void *argp2 = 0 ;
33170 int res2 = 0 ;
33171 PyObject * obj0 = 0 ;
33172 PyObject * obj1 = 0 ;
33173 char * kwnames[] = {
33174 (char *) "self",(char *) "child", NULL
33175 };
33176
33177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33179 if (!SWIG_IsOK(res1)) {
33180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33181 }
33182 arg1 = reinterpret_cast< wxWindow * >(argp1);
33183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33184 if (!SWIG_IsOK(res2)) {
33185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33186 }
33187 arg2 = reinterpret_cast< wxWindow * >(argp2);
33188 {
33189 PyThreadState* __tstate = wxPyBeginAllowThreads();
33190 (arg1)->RemoveChild(arg2);
33191 wxPyEndAllowThreads(__tstate);
33192 if (PyErr_Occurred()) SWIG_fail;
33193 }
33194 resultobj = SWIG_Py_Void();
33195 return resultobj;
33196 fail:
33197 return NULL;
33198 }
33199
33200
33201 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33202 PyObject *resultobj = 0;
33203 wxWindow *arg1 = (wxWindow *) 0 ;
33204 long arg2 ;
33205 wxWindow *result = 0 ;
33206 void *argp1 = 0 ;
33207 int res1 = 0 ;
33208 long val2 ;
33209 int ecode2 = 0 ;
33210 PyObject * obj0 = 0 ;
33211 PyObject * obj1 = 0 ;
33212 char * kwnames[] = {
33213 (char *) "self",(char *) "winid", NULL
33214 };
33215
33216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33218 if (!SWIG_IsOK(res1)) {
33219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33220 }
33221 arg1 = reinterpret_cast< wxWindow * >(argp1);
33222 ecode2 = SWIG_AsVal_long(obj1, &val2);
33223 if (!SWIG_IsOK(ecode2)) {
33224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33225 }
33226 arg2 = static_cast< long >(val2);
33227 {
33228 PyThreadState* __tstate = wxPyBeginAllowThreads();
33229 result = (wxWindow *)(arg1)->FindWindow(arg2);
33230 wxPyEndAllowThreads(__tstate);
33231 if (PyErr_Occurred()) SWIG_fail;
33232 }
33233 {
33234 resultobj = wxPyMake_wxObject(result, 0);
33235 }
33236 return resultobj;
33237 fail:
33238 return NULL;
33239 }
33240
33241
33242 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33243 PyObject *resultobj = 0;
33244 wxWindow *arg1 = (wxWindow *) 0 ;
33245 wxString *arg2 = 0 ;
33246 wxWindow *result = 0 ;
33247 void *argp1 = 0 ;
33248 int res1 = 0 ;
33249 bool temp2 = false ;
33250 PyObject * obj0 = 0 ;
33251 PyObject * obj1 = 0 ;
33252 char * kwnames[] = {
33253 (char *) "self",(char *) "name", NULL
33254 };
33255
33256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33258 if (!SWIG_IsOK(res1)) {
33259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33260 }
33261 arg1 = reinterpret_cast< wxWindow * >(argp1);
33262 {
33263 arg2 = wxString_in_helper(obj1);
33264 if (arg2 == NULL) SWIG_fail;
33265 temp2 = true;
33266 }
33267 {
33268 PyThreadState* __tstate = wxPyBeginAllowThreads();
33269 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33270 wxPyEndAllowThreads(__tstate);
33271 if (PyErr_Occurred()) SWIG_fail;
33272 }
33273 {
33274 resultobj = wxPyMake_wxObject(result, 0);
33275 }
33276 {
33277 if (temp2)
33278 delete arg2;
33279 }
33280 return resultobj;
33281 fail:
33282 {
33283 if (temp2)
33284 delete arg2;
33285 }
33286 return NULL;
33287 }
33288
33289
33290 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33291 PyObject *resultobj = 0;
33292 wxWindow *arg1 = (wxWindow *) 0 ;
33293 wxEvtHandler *result = 0 ;
33294 void *argp1 = 0 ;
33295 int res1 = 0 ;
33296 PyObject *swig_obj[1] ;
33297
33298 if (!args) SWIG_fail;
33299 swig_obj[0] = args;
33300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33301 if (!SWIG_IsOK(res1)) {
33302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33303 }
33304 arg1 = reinterpret_cast< wxWindow * >(argp1);
33305 {
33306 PyThreadState* __tstate = wxPyBeginAllowThreads();
33307 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33308 wxPyEndAllowThreads(__tstate);
33309 if (PyErr_Occurred()) SWIG_fail;
33310 }
33311 {
33312 resultobj = wxPyMake_wxObject(result, 0);
33313 }
33314 return resultobj;
33315 fail:
33316 return NULL;
33317 }
33318
33319
33320 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33321 PyObject *resultobj = 0;
33322 wxWindow *arg1 = (wxWindow *) 0 ;
33323 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33324 void *argp1 = 0 ;
33325 int res1 = 0 ;
33326 void *argp2 = 0 ;
33327 int res2 = 0 ;
33328 PyObject * obj0 = 0 ;
33329 PyObject * obj1 = 0 ;
33330 char * kwnames[] = {
33331 (char *) "self",(char *) "handler", NULL
33332 };
33333
33334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33336 if (!SWIG_IsOK(res1)) {
33337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33338 }
33339 arg1 = reinterpret_cast< wxWindow * >(argp1);
33340 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33341 if (!SWIG_IsOK(res2)) {
33342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33343 }
33344 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33345 {
33346 PyThreadState* __tstate = wxPyBeginAllowThreads();
33347 (arg1)->SetEventHandler(arg2);
33348 wxPyEndAllowThreads(__tstate);
33349 if (PyErr_Occurred()) SWIG_fail;
33350 }
33351 resultobj = SWIG_Py_Void();
33352 return resultobj;
33353 fail:
33354 return NULL;
33355 }
33356
33357
33358 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33359 PyObject *resultobj = 0;
33360 wxWindow *arg1 = (wxWindow *) 0 ;
33361 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33362 void *argp1 = 0 ;
33363 int res1 = 0 ;
33364 void *argp2 = 0 ;
33365 int res2 = 0 ;
33366 PyObject * obj0 = 0 ;
33367 PyObject * obj1 = 0 ;
33368 char * kwnames[] = {
33369 (char *) "self",(char *) "handler", NULL
33370 };
33371
33372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33374 if (!SWIG_IsOK(res1)) {
33375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33376 }
33377 arg1 = reinterpret_cast< wxWindow * >(argp1);
33378 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33379 if (!SWIG_IsOK(res2)) {
33380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33381 }
33382 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33383 {
33384 PyThreadState* __tstate = wxPyBeginAllowThreads();
33385 (arg1)->PushEventHandler(arg2);
33386 wxPyEndAllowThreads(__tstate);
33387 if (PyErr_Occurred()) SWIG_fail;
33388 }
33389 resultobj = SWIG_Py_Void();
33390 return resultobj;
33391 fail:
33392 return NULL;
33393 }
33394
33395
33396 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33397 PyObject *resultobj = 0;
33398 wxWindow *arg1 = (wxWindow *) 0 ;
33399 bool arg2 = (bool) false ;
33400 wxEvtHandler *result = 0 ;
33401 void *argp1 = 0 ;
33402 int res1 = 0 ;
33403 bool val2 ;
33404 int ecode2 = 0 ;
33405 PyObject * obj0 = 0 ;
33406 PyObject * obj1 = 0 ;
33407 char * kwnames[] = {
33408 (char *) "self",(char *) "deleteHandler", NULL
33409 };
33410
33411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33413 if (!SWIG_IsOK(res1)) {
33414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33415 }
33416 arg1 = reinterpret_cast< wxWindow * >(argp1);
33417 if (obj1) {
33418 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33419 if (!SWIG_IsOK(ecode2)) {
33420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33421 }
33422 arg2 = static_cast< bool >(val2);
33423 }
33424 {
33425 PyThreadState* __tstate = wxPyBeginAllowThreads();
33426 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33427 wxPyEndAllowThreads(__tstate);
33428 if (PyErr_Occurred()) SWIG_fail;
33429 }
33430 {
33431 resultobj = wxPyMake_wxObject(result, 0);
33432 }
33433 return resultobj;
33434 fail:
33435 return NULL;
33436 }
33437
33438
33439 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33440 PyObject *resultobj = 0;
33441 wxWindow *arg1 = (wxWindow *) 0 ;
33442 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33443 bool result;
33444 void *argp1 = 0 ;
33445 int res1 = 0 ;
33446 void *argp2 = 0 ;
33447 int res2 = 0 ;
33448 PyObject * obj0 = 0 ;
33449 PyObject * obj1 = 0 ;
33450 char * kwnames[] = {
33451 (char *) "self",(char *) "handler", NULL
33452 };
33453
33454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33456 if (!SWIG_IsOK(res1)) {
33457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33458 }
33459 arg1 = reinterpret_cast< wxWindow * >(argp1);
33460 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33461 if (!SWIG_IsOK(res2)) {
33462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33463 }
33464 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33465 {
33466 PyThreadState* __tstate = wxPyBeginAllowThreads();
33467 result = (bool)(arg1)->RemoveEventHandler(arg2);
33468 wxPyEndAllowThreads(__tstate);
33469 if (PyErr_Occurred()) SWIG_fail;
33470 }
33471 {
33472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33473 }
33474 return resultobj;
33475 fail:
33476 return NULL;
33477 }
33478
33479
33480 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33481 PyObject *resultobj = 0;
33482 wxWindow *arg1 = (wxWindow *) 0 ;
33483 wxValidator *arg2 = 0 ;
33484 void *argp1 = 0 ;
33485 int res1 = 0 ;
33486 void *argp2 = 0 ;
33487 int res2 = 0 ;
33488 PyObject * obj0 = 0 ;
33489 PyObject * obj1 = 0 ;
33490 char * kwnames[] = {
33491 (char *) "self",(char *) "validator", NULL
33492 };
33493
33494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33496 if (!SWIG_IsOK(res1)) {
33497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33498 }
33499 arg1 = reinterpret_cast< wxWindow * >(argp1);
33500 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33501 if (!SWIG_IsOK(res2)) {
33502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33503 }
33504 if (!argp2) {
33505 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33506 }
33507 arg2 = reinterpret_cast< wxValidator * >(argp2);
33508 {
33509 PyThreadState* __tstate = wxPyBeginAllowThreads();
33510 (arg1)->SetValidator((wxValidator const &)*arg2);
33511 wxPyEndAllowThreads(__tstate);
33512 if (PyErr_Occurred()) SWIG_fail;
33513 }
33514 resultobj = SWIG_Py_Void();
33515 return resultobj;
33516 fail:
33517 return NULL;
33518 }
33519
33520
33521 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33522 PyObject *resultobj = 0;
33523 wxWindow *arg1 = (wxWindow *) 0 ;
33524 wxValidator *result = 0 ;
33525 void *argp1 = 0 ;
33526 int res1 = 0 ;
33527 PyObject *swig_obj[1] ;
33528
33529 if (!args) SWIG_fail;
33530 swig_obj[0] = args;
33531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33532 if (!SWIG_IsOK(res1)) {
33533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33534 }
33535 arg1 = reinterpret_cast< wxWindow * >(argp1);
33536 {
33537 PyThreadState* __tstate = wxPyBeginAllowThreads();
33538 result = (wxValidator *)(arg1)->GetValidator();
33539 wxPyEndAllowThreads(__tstate);
33540 if (PyErr_Occurred()) SWIG_fail;
33541 }
33542 {
33543 resultobj = wxPyMake_wxObject(result, (bool)0);
33544 }
33545 return resultobj;
33546 fail:
33547 return NULL;
33548 }
33549
33550
33551 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33552 PyObject *resultobj = 0;
33553 wxWindow *arg1 = (wxWindow *) 0 ;
33554 bool result;
33555 void *argp1 = 0 ;
33556 int res1 = 0 ;
33557 PyObject *swig_obj[1] ;
33558
33559 if (!args) SWIG_fail;
33560 swig_obj[0] = args;
33561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33562 if (!SWIG_IsOK(res1)) {
33563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33564 }
33565 arg1 = reinterpret_cast< wxWindow * >(argp1);
33566 {
33567 PyThreadState* __tstate = wxPyBeginAllowThreads();
33568 result = (bool)(arg1)->Validate();
33569 wxPyEndAllowThreads(__tstate);
33570 if (PyErr_Occurred()) SWIG_fail;
33571 }
33572 {
33573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33574 }
33575 return resultobj;
33576 fail:
33577 return NULL;
33578 }
33579
33580
33581 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33582 PyObject *resultobj = 0;
33583 wxWindow *arg1 = (wxWindow *) 0 ;
33584 bool result;
33585 void *argp1 = 0 ;
33586 int res1 = 0 ;
33587 PyObject *swig_obj[1] ;
33588
33589 if (!args) SWIG_fail;
33590 swig_obj[0] = args;
33591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33592 if (!SWIG_IsOK(res1)) {
33593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33594 }
33595 arg1 = reinterpret_cast< wxWindow * >(argp1);
33596 {
33597 PyThreadState* __tstate = wxPyBeginAllowThreads();
33598 result = (bool)(arg1)->TransferDataToWindow();
33599 wxPyEndAllowThreads(__tstate);
33600 if (PyErr_Occurred()) SWIG_fail;
33601 }
33602 {
33603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33604 }
33605 return resultobj;
33606 fail:
33607 return NULL;
33608 }
33609
33610
33611 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33612 PyObject *resultobj = 0;
33613 wxWindow *arg1 = (wxWindow *) 0 ;
33614 bool result;
33615 void *argp1 = 0 ;
33616 int res1 = 0 ;
33617 PyObject *swig_obj[1] ;
33618
33619 if (!args) SWIG_fail;
33620 swig_obj[0] = args;
33621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33622 if (!SWIG_IsOK(res1)) {
33623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33624 }
33625 arg1 = reinterpret_cast< wxWindow * >(argp1);
33626 {
33627 PyThreadState* __tstate = wxPyBeginAllowThreads();
33628 result = (bool)(arg1)->TransferDataFromWindow();
33629 wxPyEndAllowThreads(__tstate);
33630 if (PyErr_Occurred()) SWIG_fail;
33631 }
33632 {
33633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33634 }
33635 return resultobj;
33636 fail:
33637 return NULL;
33638 }
33639
33640
33641 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33642 PyObject *resultobj = 0;
33643 wxWindow *arg1 = (wxWindow *) 0 ;
33644 void *argp1 = 0 ;
33645 int res1 = 0 ;
33646 PyObject *swig_obj[1] ;
33647
33648 if (!args) SWIG_fail;
33649 swig_obj[0] = args;
33650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33651 if (!SWIG_IsOK(res1)) {
33652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33653 }
33654 arg1 = reinterpret_cast< wxWindow * >(argp1);
33655 {
33656 PyThreadState* __tstate = wxPyBeginAllowThreads();
33657 (arg1)->InitDialog();
33658 wxPyEndAllowThreads(__tstate);
33659 if (PyErr_Occurred()) SWIG_fail;
33660 }
33661 resultobj = SWIG_Py_Void();
33662 return resultobj;
33663 fail:
33664 return NULL;
33665 }
33666
33667
33668 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33669 PyObject *resultobj = 0;
33670 wxWindow *arg1 = (wxWindow *) 0 ;
33671 wxAcceleratorTable *arg2 = 0 ;
33672 void *argp1 = 0 ;
33673 int res1 = 0 ;
33674 void *argp2 = 0 ;
33675 int res2 = 0 ;
33676 PyObject * obj0 = 0 ;
33677 PyObject * obj1 = 0 ;
33678 char * kwnames[] = {
33679 (char *) "self",(char *) "accel", NULL
33680 };
33681
33682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33684 if (!SWIG_IsOK(res1)) {
33685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33686 }
33687 arg1 = reinterpret_cast< wxWindow * >(argp1);
33688 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33689 if (!SWIG_IsOK(res2)) {
33690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33691 }
33692 if (!argp2) {
33693 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33694 }
33695 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33696 {
33697 PyThreadState* __tstate = wxPyBeginAllowThreads();
33698 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33699 wxPyEndAllowThreads(__tstate);
33700 if (PyErr_Occurred()) SWIG_fail;
33701 }
33702 resultobj = SWIG_Py_Void();
33703 return resultobj;
33704 fail:
33705 return NULL;
33706 }
33707
33708
33709 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33710 PyObject *resultobj = 0;
33711 wxWindow *arg1 = (wxWindow *) 0 ;
33712 wxAcceleratorTable *result = 0 ;
33713 void *argp1 = 0 ;
33714 int res1 = 0 ;
33715 PyObject *swig_obj[1] ;
33716
33717 if (!args) SWIG_fail;
33718 swig_obj[0] = args;
33719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33720 if (!SWIG_IsOK(res1)) {
33721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33722 }
33723 arg1 = reinterpret_cast< wxWindow * >(argp1);
33724 {
33725 PyThreadState* __tstate = wxPyBeginAllowThreads();
33726 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33727 wxPyEndAllowThreads(__tstate);
33728 if (PyErr_Occurred()) SWIG_fail;
33729 }
33730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33731 return resultobj;
33732 fail:
33733 return NULL;
33734 }
33735
33736
33737 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33738 PyObject *resultobj = 0;
33739 wxWindow *arg1 = (wxWindow *) 0 ;
33740 int arg2 ;
33741 int arg3 ;
33742 int arg4 ;
33743 bool result;
33744 void *argp1 = 0 ;
33745 int res1 = 0 ;
33746 int val2 ;
33747 int ecode2 = 0 ;
33748 int val3 ;
33749 int ecode3 = 0 ;
33750 int val4 ;
33751 int ecode4 = 0 ;
33752 PyObject * obj0 = 0 ;
33753 PyObject * obj1 = 0 ;
33754 PyObject * obj2 = 0 ;
33755 PyObject * obj3 = 0 ;
33756 char * kwnames[] = {
33757 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33758 };
33759
33760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33762 if (!SWIG_IsOK(res1)) {
33763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33764 }
33765 arg1 = reinterpret_cast< wxWindow * >(argp1);
33766 ecode2 = SWIG_AsVal_int(obj1, &val2);
33767 if (!SWIG_IsOK(ecode2)) {
33768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33769 }
33770 arg2 = static_cast< int >(val2);
33771 ecode3 = SWIG_AsVal_int(obj2, &val3);
33772 if (!SWIG_IsOK(ecode3)) {
33773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33774 }
33775 arg3 = static_cast< int >(val3);
33776 ecode4 = SWIG_AsVal_int(obj3, &val4);
33777 if (!SWIG_IsOK(ecode4)) {
33778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33779 }
33780 arg4 = static_cast< int >(val4);
33781 {
33782 PyThreadState* __tstate = wxPyBeginAllowThreads();
33783 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33784 wxPyEndAllowThreads(__tstate);
33785 if (PyErr_Occurred()) SWIG_fail;
33786 }
33787 {
33788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33789 }
33790 return resultobj;
33791 fail:
33792 return NULL;
33793 }
33794
33795
33796 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33797 PyObject *resultobj = 0;
33798 wxWindow *arg1 = (wxWindow *) 0 ;
33799 int arg2 ;
33800 bool result;
33801 void *argp1 = 0 ;
33802 int res1 = 0 ;
33803 int val2 ;
33804 int ecode2 = 0 ;
33805 PyObject * obj0 = 0 ;
33806 PyObject * obj1 = 0 ;
33807 char * kwnames[] = {
33808 (char *) "self",(char *) "hotkeyId", NULL
33809 };
33810
33811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33813 if (!SWIG_IsOK(res1)) {
33814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33815 }
33816 arg1 = reinterpret_cast< wxWindow * >(argp1);
33817 ecode2 = SWIG_AsVal_int(obj1, &val2);
33818 if (!SWIG_IsOK(ecode2)) {
33819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33820 }
33821 arg2 = static_cast< int >(val2);
33822 {
33823 PyThreadState* __tstate = wxPyBeginAllowThreads();
33824 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33825 wxPyEndAllowThreads(__tstate);
33826 if (PyErr_Occurred()) SWIG_fail;
33827 }
33828 {
33829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33830 }
33831 return resultobj;
33832 fail:
33833 return NULL;
33834 }
33835
33836
33837 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33838 PyObject *resultobj = 0;
33839 wxWindow *arg1 = (wxWindow *) 0 ;
33840 wxPoint *arg2 = 0 ;
33841 wxPoint result;
33842 void *argp1 = 0 ;
33843 int res1 = 0 ;
33844 wxPoint temp2 ;
33845 PyObject * obj0 = 0 ;
33846 PyObject * obj1 = 0 ;
33847 char * kwnames[] = {
33848 (char *) "self",(char *) "pt", NULL
33849 };
33850
33851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33853 if (!SWIG_IsOK(res1)) {
33854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33855 }
33856 arg1 = reinterpret_cast< wxWindow * >(argp1);
33857 {
33858 arg2 = &temp2;
33859 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33860 }
33861 {
33862 PyThreadState* __tstate = wxPyBeginAllowThreads();
33863 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33864 wxPyEndAllowThreads(__tstate);
33865 if (PyErr_Occurred()) SWIG_fail;
33866 }
33867 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33868 return resultobj;
33869 fail:
33870 return NULL;
33871 }
33872
33873
33874 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33875 PyObject *resultobj = 0;
33876 wxWindow *arg1 = (wxWindow *) 0 ;
33877 wxSize *arg2 = 0 ;
33878 wxSize result;
33879 void *argp1 = 0 ;
33880 int res1 = 0 ;
33881 wxSize temp2 ;
33882 PyObject * obj0 = 0 ;
33883 PyObject * obj1 = 0 ;
33884 char * kwnames[] = {
33885 (char *) "self",(char *) "sz", NULL
33886 };
33887
33888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33890 if (!SWIG_IsOK(res1)) {
33891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33892 }
33893 arg1 = reinterpret_cast< wxWindow * >(argp1);
33894 {
33895 arg2 = &temp2;
33896 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33897 }
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33905 return resultobj;
33906 fail:
33907 return NULL;
33908 }
33909
33910
33911 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33912 PyObject *resultobj = 0;
33913 wxWindow *arg1 = (wxWindow *) 0 ;
33914 wxPoint *arg2 = 0 ;
33915 wxPoint result;
33916 void *argp1 = 0 ;
33917 int res1 = 0 ;
33918 wxPoint temp2 ;
33919 PyObject * obj0 = 0 ;
33920 PyObject * obj1 = 0 ;
33921 char * kwnames[] = {
33922 (char *) "self",(char *) "pt", NULL
33923 };
33924
33925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33927 if (!SWIG_IsOK(res1)) {
33928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33929 }
33930 arg1 = reinterpret_cast< wxWindow * >(argp1);
33931 {
33932 arg2 = &temp2;
33933 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33934 }
33935 {
33936 PyThreadState* __tstate = wxPyBeginAllowThreads();
33937 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33938 wxPyEndAllowThreads(__tstate);
33939 if (PyErr_Occurred()) SWIG_fail;
33940 }
33941 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33942 return resultobj;
33943 fail:
33944 return NULL;
33945 }
33946
33947
33948 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33949 PyObject *resultobj = 0;
33950 wxWindow *arg1 = (wxWindow *) 0 ;
33951 wxSize *arg2 = 0 ;
33952 wxSize result;
33953 void *argp1 = 0 ;
33954 int res1 = 0 ;
33955 wxSize temp2 ;
33956 PyObject * obj0 = 0 ;
33957 PyObject * obj1 = 0 ;
33958 char * kwnames[] = {
33959 (char *) "self",(char *) "sz", NULL
33960 };
33961
33962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33964 if (!SWIG_IsOK(res1)) {
33965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33966 }
33967 arg1 = reinterpret_cast< wxWindow * >(argp1);
33968 {
33969 arg2 = &temp2;
33970 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33971 }
33972 {
33973 PyThreadState* __tstate = wxPyBeginAllowThreads();
33974 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33975 wxPyEndAllowThreads(__tstate);
33976 if (PyErr_Occurred()) SWIG_fail;
33977 }
33978 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33979 return resultobj;
33980 fail:
33981 return NULL;
33982 }
33983
33984
33985 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33986 PyObject *resultobj = 0;
33987 wxWindow *arg1 = (wxWindow *) 0 ;
33988 wxPoint *arg2 = 0 ;
33989 wxPoint result;
33990 void *argp1 = 0 ;
33991 int res1 = 0 ;
33992 wxPoint temp2 ;
33993 PyObject * obj0 = 0 ;
33994 PyObject * obj1 = 0 ;
33995 char * kwnames[] = {
33996 (char *) "self",(char *) "pt", NULL
33997 };
33998
33999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34001 if (!SWIG_IsOK(res1)) {
34002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34003 }
34004 arg1 = reinterpret_cast< wxWindow * >(argp1);
34005 {
34006 arg2 = &temp2;
34007 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34008 }
34009 {
34010 PyThreadState* __tstate = wxPyBeginAllowThreads();
34011 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34012 wxPyEndAllowThreads(__tstate);
34013 if (PyErr_Occurred()) SWIG_fail;
34014 }
34015 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34016 return resultobj;
34017 fail:
34018 return NULL;
34019 }
34020
34021
34022 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34023 PyObject *resultobj = 0;
34024 wxWindow *arg1 = (wxWindow *) 0 ;
34025 wxSize *arg2 = 0 ;
34026 wxSize result;
34027 void *argp1 = 0 ;
34028 int res1 = 0 ;
34029 wxSize temp2 ;
34030 PyObject * obj0 = 0 ;
34031 PyObject * obj1 = 0 ;
34032 char * kwnames[] = {
34033 (char *) "self",(char *) "sz", NULL
34034 };
34035
34036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34038 if (!SWIG_IsOK(res1)) {
34039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34040 }
34041 arg1 = reinterpret_cast< wxWindow * >(argp1);
34042 {
34043 arg2 = &temp2;
34044 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34045 }
34046 {
34047 PyThreadState* __tstate = wxPyBeginAllowThreads();
34048 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34049 wxPyEndAllowThreads(__tstate);
34050 if (PyErr_Occurred()) SWIG_fail;
34051 }
34052 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34053 return resultobj;
34054 fail:
34055 return NULL;
34056 }
34057
34058
34059 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34060 PyObject *resultobj = 0;
34061 wxWindow *arg1 = (wxWindow *) 0 ;
34062 int arg2 ;
34063 int arg3 ;
34064 void *argp1 = 0 ;
34065 int res1 = 0 ;
34066 int val2 ;
34067 int ecode2 = 0 ;
34068 int val3 ;
34069 int ecode3 = 0 ;
34070 PyObject * obj0 = 0 ;
34071 PyObject * obj1 = 0 ;
34072 PyObject * obj2 = 0 ;
34073 char * kwnames[] = {
34074 (char *) "self",(char *) "x",(char *) "y", NULL
34075 };
34076
34077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34079 if (!SWIG_IsOK(res1)) {
34080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34081 }
34082 arg1 = reinterpret_cast< wxWindow * >(argp1);
34083 ecode2 = SWIG_AsVal_int(obj1, &val2);
34084 if (!SWIG_IsOK(ecode2)) {
34085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34086 }
34087 arg2 = static_cast< int >(val2);
34088 ecode3 = SWIG_AsVal_int(obj2, &val3);
34089 if (!SWIG_IsOK(ecode3)) {
34090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34091 }
34092 arg3 = static_cast< int >(val3);
34093 {
34094 PyThreadState* __tstate = wxPyBeginAllowThreads();
34095 (arg1)->WarpPointer(arg2,arg3);
34096 wxPyEndAllowThreads(__tstate);
34097 if (PyErr_Occurred()) SWIG_fail;
34098 }
34099 resultobj = SWIG_Py_Void();
34100 return resultobj;
34101 fail:
34102 return NULL;
34103 }
34104
34105
34106 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34107 PyObject *resultobj = 0;
34108 wxWindow *arg1 = (wxWindow *) 0 ;
34109 void *argp1 = 0 ;
34110 int res1 = 0 ;
34111 PyObject *swig_obj[1] ;
34112
34113 if (!args) SWIG_fail;
34114 swig_obj[0] = args;
34115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34116 if (!SWIG_IsOK(res1)) {
34117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34118 }
34119 arg1 = reinterpret_cast< wxWindow * >(argp1);
34120 {
34121 PyThreadState* __tstate = wxPyBeginAllowThreads();
34122 (arg1)->CaptureMouse();
34123 wxPyEndAllowThreads(__tstate);
34124 if (PyErr_Occurred()) SWIG_fail;
34125 }
34126 resultobj = SWIG_Py_Void();
34127 return resultobj;
34128 fail:
34129 return NULL;
34130 }
34131
34132
34133 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34134 PyObject *resultobj = 0;
34135 wxWindow *arg1 = (wxWindow *) 0 ;
34136 void *argp1 = 0 ;
34137 int res1 = 0 ;
34138 PyObject *swig_obj[1] ;
34139
34140 if (!args) SWIG_fail;
34141 swig_obj[0] = args;
34142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34143 if (!SWIG_IsOK(res1)) {
34144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34145 }
34146 arg1 = reinterpret_cast< wxWindow * >(argp1);
34147 {
34148 PyThreadState* __tstate = wxPyBeginAllowThreads();
34149 (arg1)->ReleaseMouse();
34150 wxPyEndAllowThreads(__tstate);
34151 if (PyErr_Occurred()) SWIG_fail;
34152 }
34153 resultobj = SWIG_Py_Void();
34154 return resultobj;
34155 fail:
34156 return NULL;
34157 }
34158
34159
34160 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34161 PyObject *resultobj = 0;
34162 wxWindow *result = 0 ;
34163
34164 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34165 {
34166 if (!wxPyCheckForApp()) SWIG_fail;
34167 PyThreadState* __tstate = wxPyBeginAllowThreads();
34168 result = (wxWindow *)wxWindow::GetCapture();
34169 wxPyEndAllowThreads(__tstate);
34170 if (PyErr_Occurred()) SWIG_fail;
34171 }
34172 {
34173 resultobj = wxPyMake_wxObject(result, 0);
34174 }
34175 return resultobj;
34176 fail:
34177 return NULL;
34178 }
34179
34180
34181 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34182 PyObject *resultobj = 0;
34183 wxWindow *arg1 = (wxWindow *) 0 ;
34184 bool result;
34185 void *argp1 = 0 ;
34186 int res1 = 0 ;
34187 PyObject *swig_obj[1] ;
34188
34189 if (!args) SWIG_fail;
34190 swig_obj[0] = args;
34191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34192 if (!SWIG_IsOK(res1)) {
34193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34194 }
34195 arg1 = reinterpret_cast< wxWindow * >(argp1);
34196 {
34197 PyThreadState* __tstate = wxPyBeginAllowThreads();
34198 result = (bool)((wxWindow const *)arg1)->HasCapture();
34199 wxPyEndAllowThreads(__tstate);
34200 if (PyErr_Occurred()) SWIG_fail;
34201 }
34202 {
34203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34204 }
34205 return resultobj;
34206 fail:
34207 return NULL;
34208 }
34209
34210
34211 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34212 PyObject *resultobj = 0;
34213 wxWindow *arg1 = (wxWindow *) 0 ;
34214 bool arg2 = (bool) true ;
34215 wxRect *arg3 = (wxRect *) NULL ;
34216 void *argp1 = 0 ;
34217 int res1 = 0 ;
34218 bool val2 ;
34219 int ecode2 = 0 ;
34220 void *argp3 = 0 ;
34221 int res3 = 0 ;
34222 PyObject * obj0 = 0 ;
34223 PyObject * obj1 = 0 ;
34224 PyObject * obj2 = 0 ;
34225 char * kwnames[] = {
34226 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34227 };
34228
34229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34231 if (!SWIG_IsOK(res1)) {
34232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34233 }
34234 arg1 = reinterpret_cast< wxWindow * >(argp1);
34235 if (obj1) {
34236 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34237 if (!SWIG_IsOK(ecode2)) {
34238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34239 }
34240 arg2 = static_cast< bool >(val2);
34241 }
34242 if (obj2) {
34243 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34244 if (!SWIG_IsOK(res3)) {
34245 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34246 }
34247 arg3 = reinterpret_cast< wxRect * >(argp3);
34248 }
34249 {
34250 PyThreadState* __tstate = wxPyBeginAllowThreads();
34251 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34252 wxPyEndAllowThreads(__tstate);
34253 if (PyErr_Occurred()) SWIG_fail;
34254 }
34255 resultobj = SWIG_Py_Void();
34256 return resultobj;
34257 fail:
34258 return NULL;
34259 }
34260
34261
34262 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34263 PyObject *resultobj = 0;
34264 wxWindow *arg1 = (wxWindow *) 0 ;
34265 wxRect *arg2 = 0 ;
34266 bool arg3 = (bool) true ;
34267 void *argp1 = 0 ;
34268 int res1 = 0 ;
34269 wxRect temp2 ;
34270 bool val3 ;
34271 int ecode3 = 0 ;
34272 PyObject * obj0 = 0 ;
34273 PyObject * obj1 = 0 ;
34274 PyObject * obj2 = 0 ;
34275 char * kwnames[] = {
34276 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34277 };
34278
34279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34281 if (!SWIG_IsOK(res1)) {
34282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34283 }
34284 arg1 = reinterpret_cast< wxWindow * >(argp1);
34285 {
34286 arg2 = &temp2;
34287 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34288 }
34289 if (obj2) {
34290 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34291 if (!SWIG_IsOK(ecode3)) {
34292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34293 }
34294 arg3 = static_cast< bool >(val3);
34295 }
34296 {
34297 PyThreadState* __tstate = wxPyBeginAllowThreads();
34298 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34299 wxPyEndAllowThreads(__tstate);
34300 if (PyErr_Occurred()) SWIG_fail;
34301 }
34302 resultobj = SWIG_Py_Void();
34303 return resultobj;
34304 fail:
34305 return NULL;
34306 }
34307
34308
34309 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34310 PyObject *resultobj = 0;
34311 wxWindow *arg1 = (wxWindow *) 0 ;
34312 void *argp1 = 0 ;
34313 int res1 = 0 ;
34314 PyObject *swig_obj[1] ;
34315
34316 if (!args) SWIG_fail;
34317 swig_obj[0] = args;
34318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34319 if (!SWIG_IsOK(res1)) {
34320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34321 }
34322 arg1 = reinterpret_cast< wxWindow * >(argp1);
34323 {
34324 PyThreadState* __tstate = wxPyBeginAllowThreads();
34325 (arg1)->Update();
34326 wxPyEndAllowThreads(__tstate);
34327 if (PyErr_Occurred()) SWIG_fail;
34328 }
34329 resultobj = SWIG_Py_Void();
34330 return resultobj;
34331 fail:
34332 return NULL;
34333 }
34334
34335
34336 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34337 PyObject *resultobj = 0;
34338 wxWindow *arg1 = (wxWindow *) 0 ;
34339 void *argp1 = 0 ;
34340 int res1 = 0 ;
34341 PyObject *swig_obj[1] ;
34342
34343 if (!args) SWIG_fail;
34344 swig_obj[0] = args;
34345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34346 if (!SWIG_IsOK(res1)) {
34347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34348 }
34349 arg1 = reinterpret_cast< wxWindow * >(argp1);
34350 {
34351 PyThreadState* __tstate = wxPyBeginAllowThreads();
34352 (arg1)->ClearBackground();
34353 wxPyEndAllowThreads(__tstate);
34354 if (PyErr_Occurred()) SWIG_fail;
34355 }
34356 resultobj = SWIG_Py_Void();
34357 return resultobj;
34358 fail:
34359 return NULL;
34360 }
34361
34362
34363 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34364 PyObject *resultobj = 0;
34365 wxWindow *arg1 = (wxWindow *) 0 ;
34366 void *argp1 = 0 ;
34367 int res1 = 0 ;
34368 PyObject *swig_obj[1] ;
34369
34370 if (!args) SWIG_fail;
34371 swig_obj[0] = args;
34372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34373 if (!SWIG_IsOK(res1)) {
34374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34375 }
34376 arg1 = reinterpret_cast< wxWindow * >(argp1);
34377 {
34378 PyThreadState* __tstate = wxPyBeginAllowThreads();
34379 (arg1)->Freeze();
34380 wxPyEndAllowThreads(__tstate);
34381 if (PyErr_Occurred()) SWIG_fail;
34382 }
34383 resultobj = SWIG_Py_Void();
34384 return resultobj;
34385 fail:
34386 return NULL;
34387 }
34388
34389
34390 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34391 PyObject *resultobj = 0;
34392 wxWindow *arg1 = (wxWindow *) 0 ;
34393 void *argp1 = 0 ;
34394 int res1 = 0 ;
34395 PyObject *swig_obj[1] ;
34396
34397 if (!args) SWIG_fail;
34398 swig_obj[0] = args;
34399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34400 if (!SWIG_IsOK(res1)) {
34401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34402 }
34403 arg1 = reinterpret_cast< wxWindow * >(argp1);
34404 {
34405 PyThreadState* __tstate = wxPyBeginAllowThreads();
34406 (arg1)->Thaw();
34407 wxPyEndAllowThreads(__tstate);
34408 if (PyErr_Occurred()) SWIG_fail;
34409 }
34410 resultobj = SWIG_Py_Void();
34411 return resultobj;
34412 fail:
34413 return NULL;
34414 }
34415
34416
34417 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34418 PyObject *resultobj = 0;
34419 wxWindow *arg1 = (wxWindow *) 0 ;
34420 wxDC *arg2 = 0 ;
34421 void *argp1 = 0 ;
34422 int res1 = 0 ;
34423 void *argp2 = 0 ;
34424 int res2 = 0 ;
34425 PyObject * obj0 = 0 ;
34426 PyObject * obj1 = 0 ;
34427 char * kwnames[] = {
34428 (char *) "self",(char *) "dc", NULL
34429 };
34430
34431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34433 if (!SWIG_IsOK(res1)) {
34434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34435 }
34436 arg1 = reinterpret_cast< wxWindow * >(argp1);
34437 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34438 if (!SWIG_IsOK(res2)) {
34439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34440 }
34441 if (!argp2) {
34442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34443 }
34444 arg2 = reinterpret_cast< wxDC * >(argp2);
34445 {
34446 PyThreadState* __tstate = wxPyBeginAllowThreads();
34447 (arg1)->PrepareDC(*arg2);
34448 wxPyEndAllowThreads(__tstate);
34449 if (PyErr_Occurred()) SWIG_fail;
34450 }
34451 resultobj = SWIG_Py_Void();
34452 return resultobj;
34453 fail:
34454 return NULL;
34455 }
34456
34457
34458 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34459 PyObject *resultobj = 0;
34460 wxWindow *arg1 = (wxWindow *) 0 ;
34461 wxRegion *result = 0 ;
34462 void *argp1 = 0 ;
34463 int res1 = 0 ;
34464 PyObject *swig_obj[1] ;
34465
34466 if (!args) SWIG_fail;
34467 swig_obj[0] = args;
34468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34469 if (!SWIG_IsOK(res1)) {
34470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34471 }
34472 arg1 = reinterpret_cast< wxWindow * >(argp1);
34473 {
34474 PyThreadState* __tstate = wxPyBeginAllowThreads();
34475 {
34476 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34477 result = (wxRegion *) &_result_ref;
34478 }
34479 wxPyEndAllowThreads(__tstate);
34480 if (PyErr_Occurred()) SWIG_fail;
34481 }
34482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34483 return resultobj;
34484 fail:
34485 return NULL;
34486 }
34487
34488
34489 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34490 PyObject *resultobj = 0;
34491 wxWindow *arg1 = (wxWindow *) 0 ;
34492 wxRect result;
34493 void *argp1 = 0 ;
34494 int res1 = 0 ;
34495 PyObject *swig_obj[1] ;
34496
34497 if (!args) SWIG_fail;
34498 swig_obj[0] = args;
34499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34500 if (!SWIG_IsOK(res1)) {
34501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34502 }
34503 arg1 = reinterpret_cast< wxWindow * >(argp1);
34504 {
34505 PyThreadState* __tstate = wxPyBeginAllowThreads();
34506 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34507 wxPyEndAllowThreads(__tstate);
34508 if (PyErr_Occurred()) SWIG_fail;
34509 }
34510 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34511 return resultobj;
34512 fail:
34513 return NULL;
34514 }
34515
34516
34517 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34518 PyObject *resultobj = 0;
34519 wxWindow *arg1 = (wxWindow *) 0 ;
34520 int arg2 ;
34521 int arg3 ;
34522 int arg4 = (int) 1 ;
34523 int arg5 = (int) 1 ;
34524 bool result;
34525 void *argp1 = 0 ;
34526 int res1 = 0 ;
34527 int val2 ;
34528 int ecode2 = 0 ;
34529 int val3 ;
34530 int ecode3 = 0 ;
34531 int val4 ;
34532 int ecode4 = 0 ;
34533 int val5 ;
34534 int ecode5 = 0 ;
34535 PyObject * obj0 = 0 ;
34536 PyObject * obj1 = 0 ;
34537 PyObject * obj2 = 0 ;
34538 PyObject * obj3 = 0 ;
34539 PyObject * obj4 = 0 ;
34540 char * kwnames[] = {
34541 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34542 };
34543
34544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34546 if (!SWIG_IsOK(res1)) {
34547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34548 }
34549 arg1 = reinterpret_cast< wxWindow * >(argp1);
34550 ecode2 = SWIG_AsVal_int(obj1, &val2);
34551 if (!SWIG_IsOK(ecode2)) {
34552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34553 }
34554 arg2 = static_cast< int >(val2);
34555 ecode3 = SWIG_AsVal_int(obj2, &val3);
34556 if (!SWIG_IsOK(ecode3)) {
34557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34558 }
34559 arg3 = static_cast< int >(val3);
34560 if (obj3) {
34561 ecode4 = SWIG_AsVal_int(obj3, &val4);
34562 if (!SWIG_IsOK(ecode4)) {
34563 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34564 }
34565 arg4 = static_cast< int >(val4);
34566 }
34567 if (obj4) {
34568 ecode5 = SWIG_AsVal_int(obj4, &val5);
34569 if (!SWIG_IsOK(ecode5)) {
34570 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34571 }
34572 arg5 = static_cast< int >(val5);
34573 }
34574 {
34575 PyThreadState* __tstate = wxPyBeginAllowThreads();
34576 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34577 wxPyEndAllowThreads(__tstate);
34578 if (PyErr_Occurred()) SWIG_fail;
34579 }
34580 {
34581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34582 }
34583 return resultobj;
34584 fail:
34585 return NULL;
34586 }
34587
34588
34589 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34590 PyObject *resultobj = 0;
34591 wxWindow *arg1 = (wxWindow *) 0 ;
34592 wxPoint *arg2 = 0 ;
34593 bool result;
34594 void *argp1 = 0 ;
34595 int res1 = 0 ;
34596 wxPoint temp2 ;
34597 PyObject * obj0 = 0 ;
34598 PyObject * obj1 = 0 ;
34599 char * kwnames[] = {
34600 (char *) "self",(char *) "pt", NULL
34601 };
34602
34603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34605 if (!SWIG_IsOK(res1)) {
34606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34607 }
34608 arg1 = reinterpret_cast< wxWindow * >(argp1);
34609 {
34610 arg2 = &temp2;
34611 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34612 }
34613 {
34614 PyThreadState* __tstate = wxPyBeginAllowThreads();
34615 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34616 wxPyEndAllowThreads(__tstate);
34617 if (PyErr_Occurred()) SWIG_fail;
34618 }
34619 {
34620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34621 }
34622 return resultobj;
34623 fail:
34624 return NULL;
34625 }
34626
34627
34628 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34629 PyObject *resultobj = 0;
34630 wxWindow *arg1 = (wxWindow *) 0 ;
34631 wxRect *arg2 = 0 ;
34632 bool result;
34633 void *argp1 = 0 ;
34634 int res1 = 0 ;
34635 wxRect temp2 ;
34636 PyObject * obj0 = 0 ;
34637 PyObject * obj1 = 0 ;
34638 char * kwnames[] = {
34639 (char *) "self",(char *) "rect", NULL
34640 };
34641
34642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34644 if (!SWIG_IsOK(res1)) {
34645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34646 }
34647 arg1 = reinterpret_cast< wxWindow * >(argp1);
34648 {
34649 arg2 = &temp2;
34650 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34651 }
34652 {
34653 PyThreadState* __tstate = wxPyBeginAllowThreads();
34654 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34655 wxPyEndAllowThreads(__tstate);
34656 if (PyErr_Occurred()) SWIG_fail;
34657 }
34658 {
34659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34660 }
34661 return resultobj;
34662 fail:
34663 return NULL;
34664 }
34665
34666
34667 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34668 PyObject *resultobj = 0;
34669 wxWindow *arg1 = (wxWindow *) 0 ;
34670 SwigValueWrapper<wxVisualAttributes > result;
34671 void *argp1 = 0 ;
34672 int res1 = 0 ;
34673 PyObject *swig_obj[1] ;
34674
34675 if (!args) SWIG_fail;
34676 swig_obj[0] = args;
34677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34678 if (!SWIG_IsOK(res1)) {
34679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34680 }
34681 arg1 = reinterpret_cast< wxWindow * >(argp1);
34682 {
34683 PyThreadState* __tstate = wxPyBeginAllowThreads();
34684 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34685 wxPyEndAllowThreads(__tstate);
34686 if (PyErr_Occurred()) SWIG_fail;
34687 }
34688 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34689 return resultobj;
34690 fail:
34691 return NULL;
34692 }
34693
34694
34695 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34696 PyObject *resultobj = 0;
34697 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34698 SwigValueWrapper<wxVisualAttributes > result;
34699 int val1 ;
34700 int ecode1 = 0 ;
34701 PyObject * obj0 = 0 ;
34702 char * kwnames[] = {
34703 (char *) "variant", NULL
34704 };
34705
34706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34707 if (obj0) {
34708 ecode1 = SWIG_AsVal_int(obj0, &val1);
34709 if (!SWIG_IsOK(ecode1)) {
34710 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34711 }
34712 arg1 = static_cast< wxWindowVariant >(val1);
34713 }
34714 {
34715 if (!wxPyCheckForApp()) SWIG_fail;
34716 PyThreadState* __tstate = wxPyBeginAllowThreads();
34717 result = wxWindow::GetClassDefaultAttributes(arg1);
34718 wxPyEndAllowThreads(__tstate);
34719 if (PyErr_Occurred()) SWIG_fail;
34720 }
34721 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34722 return resultobj;
34723 fail:
34724 return NULL;
34725 }
34726
34727
34728 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34729 PyObject *resultobj = 0;
34730 wxWindow *arg1 = (wxWindow *) 0 ;
34731 wxColour *arg2 = 0 ;
34732 bool result;
34733 void *argp1 = 0 ;
34734 int res1 = 0 ;
34735 wxColour temp2 ;
34736 PyObject * obj0 = 0 ;
34737 PyObject * obj1 = 0 ;
34738 char * kwnames[] = {
34739 (char *) "self",(char *) "colour", NULL
34740 };
34741
34742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34744 if (!SWIG_IsOK(res1)) {
34745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34746 }
34747 arg1 = reinterpret_cast< wxWindow * >(argp1);
34748 {
34749 arg2 = &temp2;
34750 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34751 }
34752 {
34753 PyThreadState* __tstate = wxPyBeginAllowThreads();
34754 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34755 wxPyEndAllowThreads(__tstate);
34756 if (PyErr_Occurred()) SWIG_fail;
34757 }
34758 {
34759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34760 }
34761 return resultobj;
34762 fail:
34763 return NULL;
34764 }
34765
34766
34767 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34768 PyObject *resultobj = 0;
34769 wxWindow *arg1 = (wxWindow *) 0 ;
34770 wxColour *arg2 = 0 ;
34771 void *argp1 = 0 ;
34772 int res1 = 0 ;
34773 wxColour temp2 ;
34774 PyObject * obj0 = 0 ;
34775 PyObject * obj1 = 0 ;
34776 char * kwnames[] = {
34777 (char *) "self",(char *) "colour", NULL
34778 };
34779
34780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34782 if (!SWIG_IsOK(res1)) {
34783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34784 }
34785 arg1 = reinterpret_cast< wxWindow * >(argp1);
34786 {
34787 arg2 = &temp2;
34788 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34789 }
34790 {
34791 PyThreadState* __tstate = wxPyBeginAllowThreads();
34792 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34793 wxPyEndAllowThreads(__tstate);
34794 if (PyErr_Occurred()) SWIG_fail;
34795 }
34796 resultobj = SWIG_Py_Void();
34797 return resultobj;
34798 fail:
34799 return NULL;
34800 }
34801
34802
34803 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34804 PyObject *resultobj = 0;
34805 wxWindow *arg1 = (wxWindow *) 0 ;
34806 wxColour *arg2 = 0 ;
34807 bool result;
34808 void *argp1 = 0 ;
34809 int res1 = 0 ;
34810 wxColour temp2 ;
34811 PyObject * obj0 = 0 ;
34812 PyObject * obj1 = 0 ;
34813 char * kwnames[] = {
34814 (char *) "self",(char *) "colour", NULL
34815 };
34816
34817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34819 if (!SWIG_IsOK(res1)) {
34820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34821 }
34822 arg1 = reinterpret_cast< wxWindow * >(argp1);
34823 {
34824 arg2 = &temp2;
34825 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34826 }
34827 {
34828 PyThreadState* __tstate = wxPyBeginAllowThreads();
34829 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34830 wxPyEndAllowThreads(__tstate);
34831 if (PyErr_Occurred()) SWIG_fail;
34832 }
34833 {
34834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34835 }
34836 return resultobj;
34837 fail:
34838 return NULL;
34839 }
34840
34841
34842 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34843 PyObject *resultobj = 0;
34844 wxWindow *arg1 = (wxWindow *) 0 ;
34845 wxColour *arg2 = 0 ;
34846 void *argp1 = 0 ;
34847 int res1 = 0 ;
34848 wxColour temp2 ;
34849 PyObject * obj0 = 0 ;
34850 PyObject * obj1 = 0 ;
34851 char * kwnames[] = {
34852 (char *) "self",(char *) "colour", NULL
34853 };
34854
34855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34857 if (!SWIG_IsOK(res1)) {
34858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34859 }
34860 arg1 = reinterpret_cast< wxWindow * >(argp1);
34861 {
34862 arg2 = &temp2;
34863 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34864 }
34865 {
34866 PyThreadState* __tstate = wxPyBeginAllowThreads();
34867 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34868 wxPyEndAllowThreads(__tstate);
34869 if (PyErr_Occurred()) SWIG_fail;
34870 }
34871 resultobj = SWIG_Py_Void();
34872 return resultobj;
34873 fail:
34874 return NULL;
34875 }
34876
34877
34878 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34879 PyObject *resultobj = 0;
34880 wxWindow *arg1 = (wxWindow *) 0 ;
34881 wxColour result;
34882 void *argp1 = 0 ;
34883 int res1 = 0 ;
34884 PyObject *swig_obj[1] ;
34885
34886 if (!args) SWIG_fail;
34887 swig_obj[0] = args;
34888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34889 if (!SWIG_IsOK(res1)) {
34890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34891 }
34892 arg1 = reinterpret_cast< wxWindow * >(argp1);
34893 {
34894 PyThreadState* __tstate = wxPyBeginAllowThreads();
34895 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34896 wxPyEndAllowThreads(__tstate);
34897 if (PyErr_Occurred()) SWIG_fail;
34898 }
34899 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34900 return resultobj;
34901 fail:
34902 return NULL;
34903 }
34904
34905
34906 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34907 PyObject *resultobj = 0;
34908 wxWindow *arg1 = (wxWindow *) 0 ;
34909 wxColour result;
34910 void *argp1 = 0 ;
34911 int res1 = 0 ;
34912 PyObject *swig_obj[1] ;
34913
34914 if (!args) SWIG_fail;
34915 swig_obj[0] = args;
34916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34917 if (!SWIG_IsOK(res1)) {
34918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34919 }
34920 arg1 = reinterpret_cast< wxWindow * >(argp1);
34921 {
34922 PyThreadState* __tstate = wxPyBeginAllowThreads();
34923 result = ((wxWindow const *)arg1)->GetForegroundColour();
34924 wxPyEndAllowThreads(__tstate);
34925 if (PyErr_Occurred()) SWIG_fail;
34926 }
34927 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34928 return resultobj;
34929 fail:
34930 return NULL;
34931 }
34932
34933
34934 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34935 PyObject *resultobj = 0;
34936 wxWindow *arg1 = (wxWindow *) 0 ;
34937 bool result;
34938 void *argp1 = 0 ;
34939 int res1 = 0 ;
34940 PyObject *swig_obj[1] ;
34941
34942 if (!args) SWIG_fail;
34943 swig_obj[0] = args;
34944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34945 if (!SWIG_IsOK(res1)) {
34946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34947 }
34948 arg1 = reinterpret_cast< wxWindow * >(argp1);
34949 {
34950 PyThreadState* __tstate = wxPyBeginAllowThreads();
34951 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34952 wxPyEndAllowThreads(__tstate);
34953 if (PyErr_Occurred()) SWIG_fail;
34954 }
34955 {
34956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34957 }
34958 return resultobj;
34959 fail:
34960 return NULL;
34961 }
34962
34963
34964 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34965 PyObject *resultobj = 0;
34966 wxWindow *arg1 = (wxWindow *) 0 ;
34967 bool result;
34968 void *argp1 = 0 ;
34969 int res1 = 0 ;
34970 PyObject *swig_obj[1] ;
34971
34972 if (!args) SWIG_fail;
34973 swig_obj[0] = args;
34974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34975 if (!SWIG_IsOK(res1)) {
34976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34977 }
34978 arg1 = reinterpret_cast< wxWindow * >(argp1);
34979 {
34980 PyThreadState* __tstate = wxPyBeginAllowThreads();
34981 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34982 wxPyEndAllowThreads(__tstate);
34983 if (PyErr_Occurred()) SWIG_fail;
34984 }
34985 {
34986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34987 }
34988 return resultobj;
34989 fail:
34990 return NULL;
34991 }
34992
34993
34994 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34995 PyObject *resultobj = 0;
34996 wxWindow *arg1 = (wxWindow *) 0 ;
34997 wxBackgroundStyle arg2 ;
34998 bool result;
34999 void *argp1 = 0 ;
35000 int res1 = 0 ;
35001 int val2 ;
35002 int ecode2 = 0 ;
35003 PyObject * obj0 = 0 ;
35004 PyObject * obj1 = 0 ;
35005 char * kwnames[] = {
35006 (char *) "self",(char *) "style", NULL
35007 };
35008
35009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35011 if (!SWIG_IsOK(res1)) {
35012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35013 }
35014 arg1 = reinterpret_cast< wxWindow * >(argp1);
35015 ecode2 = SWIG_AsVal_int(obj1, &val2);
35016 if (!SWIG_IsOK(ecode2)) {
35017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35018 }
35019 arg2 = static_cast< wxBackgroundStyle >(val2);
35020 {
35021 PyThreadState* __tstate = wxPyBeginAllowThreads();
35022 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35023 wxPyEndAllowThreads(__tstate);
35024 if (PyErr_Occurred()) SWIG_fail;
35025 }
35026 {
35027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35028 }
35029 return resultobj;
35030 fail:
35031 return NULL;
35032 }
35033
35034
35035 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35036 PyObject *resultobj = 0;
35037 wxWindow *arg1 = (wxWindow *) 0 ;
35038 wxBackgroundStyle result;
35039 void *argp1 = 0 ;
35040 int res1 = 0 ;
35041 PyObject *swig_obj[1] ;
35042
35043 if (!args) SWIG_fail;
35044 swig_obj[0] = args;
35045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35046 if (!SWIG_IsOK(res1)) {
35047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35048 }
35049 arg1 = reinterpret_cast< wxWindow * >(argp1);
35050 {
35051 PyThreadState* __tstate = wxPyBeginAllowThreads();
35052 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35053 wxPyEndAllowThreads(__tstate);
35054 if (PyErr_Occurred()) SWIG_fail;
35055 }
35056 resultobj = SWIG_From_int(static_cast< int >(result));
35057 return resultobj;
35058 fail:
35059 return NULL;
35060 }
35061
35062
35063 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35064 PyObject *resultobj = 0;
35065 wxWindow *arg1 = (wxWindow *) 0 ;
35066 bool result;
35067 void *argp1 = 0 ;
35068 int res1 = 0 ;
35069 PyObject *swig_obj[1] ;
35070
35071 if (!args) SWIG_fail;
35072 swig_obj[0] = args;
35073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35074 if (!SWIG_IsOK(res1)) {
35075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35076 }
35077 arg1 = reinterpret_cast< wxWindow * >(argp1);
35078 {
35079 PyThreadState* __tstate = wxPyBeginAllowThreads();
35080 result = (bool)(arg1)->HasTransparentBackground();
35081 wxPyEndAllowThreads(__tstate);
35082 if (PyErr_Occurred()) SWIG_fail;
35083 }
35084 {
35085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35086 }
35087 return resultobj;
35088 fail:
35089 return NULL;
35090 }
35091
35092
35093 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35094 PyObject *resultobj = 0;
35095 wxWindow *arg1 = (wxWindow *) 0 ;
35096 wxCursor *arg2 = 0 ;
35097 bool result;
35098 void *argp1 = 0 ;
35099 int res1 = 0 ;
35100 void *argp2 = 0 ;
35101 int res2 = 0 ;
35102 PyObject * obj0 = 0 ;
35103 PyObject * obj1 = 0 ;
35104 char * kwnames[] = {
35105 (char *) "self",(char *) "cursor", NULL
35106 };
35107
35108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35110 if (!SWIG_IsOK(res1)) {
35111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35112 }
35113 arg1 = reinterpret_cast< wxWindow * >(argp1);
35114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35115 if (!SWIG_IsOK(res2)) {
35116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35117 }
35118 if (!argp2) {
35119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35120 }
35121 arg2 = reinterpret_cast< wxCursor * >(argp2);
35122 {
35123 PyThreadState* __tstate = wxPyBeginAllowThreads();
35124 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35125 wxPyEndAllowThreads(__tstate);
35126 if (PyErr_Occurred()) SWIG_fail;
35127 }
35128 {
35129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35130 }
35131 return resultobj;
35132 fail:
35133 return NULL;
35134 }
35135
35136
35137 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35138 PyObject *resultobj = 0;
35139 wxWindow *arg1 = (wxWindow *) 0 ;
35140 wxCursor result;
35141 void *argp1 = 0 ;
35142 int res1 = 0 ;
35143 PyObject *swig_obj[1] ;
35144
35145 if (!args) SWIG_fail;
35146 swig_obj[0] = args;
35147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35148 if (!SWIG_IsOK(res1)) {
35149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35150 }
35151 arg1 = reinterpret_cast< wxWindow * >(argp1);
35152 {
35153 PyThreadState* __tstate = wxPyBeginAllowThreads();
35154 result = (arg1)->GetCursor();
35155 wxPyEndAllowThreads(__tstate);
35156 if (PyErr_Occurred()) SWIG_fail;
35157 }
35158 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35159 return resultobj;
35160 fail:
35161 return NULL;
35162 }
35163
35164
35165 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35166 PyObject *resultobj = 0;
35167 wxWindow *arg1 = (wxWindow *) 0 ;
35168 wxFont *arg2 = 0 ;
35169 bool result;
35170 void *argp1 = 0 ;
35171 int res1 = 0 ;
35172 void *argp2 = 0 ;
35173 int res2 = 0 ;
35174 PyObject * obj0 = 0 ;
35175 PyObject * obj1 = 0 ;
35176 char * kwnames[] = {
35177 (char *) "self",(char *) "font", NULL
35178 };
35179
35180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35182 if (!SWIG_IsOK(res1)) {
35183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35184 }
35185 arg1 = reinterpret_cast< wxWindow * >(argp1);
35186 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35187 if (!SWIG_IsOK(res2)) {
35188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35189 }
35190 if (!argp2) {
35191 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35192 }
35193 arg2 = reinterpret_cast< wxFont * >(argp2);
35194 {
35195 PyThreadState* __tstate = wxPyBeginAllowThreads();
35196 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35197 wxPyEndAllowThreads(__tstate);
35198 if (PyErr_Occurred()) SWIG_fail;
35199 }
35200 {
35201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35202 }
35203 return resultobj;
35204 fail:
35205 return NULL;
35206 }
35207
35208
35209 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35210 PyObject *resultobj = 0;
35211 wxWindow *arg1 = (wxWindow *) 0 ;
35212 wxFont *arg2 = 0 ;
35213 void *argp1 = 0 ;
35214 int res1 = 0 ;
35215 void *argp2 = 0 ;
35216 int res2 = 0 ;
35217 PyObject * obj0 = 0 ;
35218 PyObject * obj1 = 0 ;
35219 char * kwnames[] = {
35220 (char *) "self",(char *) "font", NULL
35221 };
35222
35223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35225 if (!SWIG_IsOK(res1)) {
35226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35227 }
35228 arg1 = reinterpret_cast< wxWindow * >(argp1);
35229 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35230 if (!SWIG_IsOK(res2)) {
35231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35232 }
35233 if (!argp2) {
35234 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35235 }
35236 arg2 = reinterpret_cast< wxFont * >(argp2);
35237 {
35238 PyThreadState* __tstate = wxPyBeginAllowThreads();
35239 (arg1)->SetOwnFont((wxFont const &)*arg2);
35240 wxPyEndAllowThreads(__tstate);
35241 if (PyErr_Occurred()) SWIG_fail;
35242 }
35243 resultobj = SWIG_Py_Void();
35244 return resultobj;
35245 fail:
35246 return NULL;
35247 }
35248
35249
35250 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35251 PyObject *resultobj = 0;
35252 wxWindow *arg1 = (wxWindow *) 0 ;
35253 wxFont result;
35254 void *argp1 = 0 ;
35255 int res1 = 0 ;
35256 PyObject *swig_obj[1] ;
35257
35258 if (!args) SWIG_fail;
35259 swig_obj[0] = args;
35260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35261 if (!SWIG_IsOK(res1)) {
35262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35263 }
35264 arg1 = reinterpret_cast< wxWindow * >(argp1);
35265 {
35266 PyThreadState* __tstate = wxPyBeginAllowThreads();
35267 result = (arg1)->GetFont();
35268 wxPyEndAllowThreads(__tstate);
35269 if (PyErr_Occurred()) SWIG_fail;
35270 }
35271 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35272 return resultobj;
35273 fail:
35274 return NULL;
35275 }
35276
35277
35278 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35279 PyObject *resultobj = 0;
35280 wxWindow *arg1 = (wxWindow *) 0 ;
35281 wxCaret *arg2 = (wxCaret *) 0 ;
35282 void *argp1 = 0 ;
35283 int res1 = 0 ;
35284 int res2 = 0 ;
35285 PyObject * obj0 = 0 ;
35286 PyObject * obj1 = 0 ;
35287 char * kwnames[] = {
35288 (char *) "self",(char *) "caret", NULL
35289 };
35290
35291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35293 if (!SWIG_IsOK(res1)) {
35294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35295 }
35296 arg1 = reinterpret_cast< wxWindow * >(argp1);
35297 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35298 if (!SWIG_IsOK(res2)) {
35299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35300 }
35301 {
35302 PyThreadState* __tstate = wxPyBeginAllowThreads();
35303 (arg1)->SetCaret(arg2);
35304 wxPyEndAllowThreads(__tstate);
35305 if (PyErr_Occurred()) SWIG_fail;
35306 }
35307 resultobj = SWIG_Py_Void();
35308 return resultobj;
35309 fail:
35310 return NULL;
35311 }
35312
35313
35314 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35315 PyObject *resultobj = 0;
35316 wxWindow *arg1 = (wxWindow *) 0 ;
35317 wxCaret *result = 0 ;
35318 void *argp1 = 0 ;
35319 int res1 = 0 ;
35320 PyObject *swig_obj[1] ;
35321
35322 if (!args) SWIG_fail;
35323 swig_obj[0] = args;
35324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35325 if (!SWIG_IsOK(res1)) {
35326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35327 }
35328 arg1 = reinterpret_cast< wxWindow * >(argp1);
35329 {
35330 PyThreadState* __tstate = wxPyBeginAllowThreads();
35331 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35332 wxPyEndAllowThreads(__tstate);
35333 if (PyErr_Occurred()) SWIG_fail;
35334 }
35335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35336 return resultobj;
35337 fail:
35338 return NULL;
35339 }
35340
35341
35342 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35343 PyObject *resultobj = 0;
35344 wxWindow *arg1 = (wxWindow *) 0 ;
35345 int result;
35346 void *argp1 = 0 ;
35347 int res1 = 0 ;
35348 PyObject *swig_obj[1] ;
35349
35350 if (!args) SWIG_fail;
35351 swig_obj[0] = args;
35352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35353 if (!SWIG_IsOK(res1)) {
35354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35355 }
35356 arg1 = reinterpret_cast< wxWindow * >(argp1);
35357 {
35358 PyThreadState* __tstate = wxPyBeginAllowThreads();
35359 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35360 wxPyEndAllowThreads(__tstate);
35361 if (PyErr_Occurred()) SWIG_fail;
35362 }
35363 resultobj = SWIG_From_int(static_cast< int >(result));
35364 return resultobj;
35365 fail:
35366 return NULL;
35367 }
35368
35369
35370 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35371 PyObject *resultobj = 0;
35372 wxWindow *arg1 = (wxWindow *) 0 ;
35373 int result;
35374 void *argp1 = 0 ;
35375 int res1 = 0 ;
35376 PyObject *swig_obj[1] ;
35377
35378 if (!args) SWIG_fail;
35379 swig_obj[0] = args;
35380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35381 if (!SWIG_IsOK(res1)) {
35382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35383 }
35384 arg1 = reinterpret_cast< wxWindow * >(argp1);
35385 {
35386 PyThreadState* __tstate = wxPyBeginAllowThreads();
35387 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35388 wxPyEndAllowThreads(__tstate);
35389 if (PyErr_Occurred()) SWIG_fail;
35390 }
35391 resultobj = SWIG_From_int(static_cast< int >(result));
35392 return resultobj;
35393 fail:
35394 return NULL;
35395 }
35396
35397
35398 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35399 PyObject *resultobj = 0;
35400 wxWindow *arg1 = (wxWindow *) 0 ;
35401 wxString *arg2 = 0 ;
35402 int *arg3 = (int *) 0 ;
35403 int *arg4 = (int *) 0 ;
35404 void *argp1 = 0 ;
35405 int res1 = 0 ;
35406 bool temp2 = false ;
35407 int temp3 ;
35408 int res3 = SWIG_TMPOBJ ;
35409 int temp4 ;
35410 int res4 = SWIG_TMPOBJ ;
35411 PyObject * obj0 = 0 ;
35412 PyObject * obj1 = 0 ;
35413 char * kwnames[] = {
35414 (char *) "self",(char *) "string", NULL
35415 };
35416
35417 arg3 = &temp3;
35418 arg4 = &temp4;
35419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35421 if (!SWIG_IsOK(res1)) {
35422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35423 }
35424 arg1 = reinterpret_cast< wxWindow * >(argp1);
35425 {
35426 arg2 = wxString_in_helper(obj1);
35427 if (arg2 == NULL) SWIG_fail;
35428 temp2 = true;
35429 }
35430 {
35431 PyThreadState* __tstate = wxPyBeginAllowThreads();
35432 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35433 wxPyEndAllowThreads(__tstate);
35434 if (PyErr_Occurred()) SWIG_fail;
35435 }
35436 resultobj = SWIG_Py_Void();
35437 if (SWIG_IsTmpObj(res3)) {
35438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35439 } else {
35440 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35442 }
35443 if (SWIG_IsTmpObj(res4)) {
35444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35445 } else {
35446 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35447 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35448 }
35449 {
35450 if (temp2)
35451 delete arg2;
35452 }
35453 return resultobj;
35454 fail:
35455 {
35456 if (temp2)
35457 delete arg2;
35458 }
35459 return NULL;
35460 }
35461
35462
35463 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35464 PyObject *resultobj = 0;
35465 wxWindow *arg1 = (wxWindow *) 0 ;
35466 wxString *arg2 = 0 ;
35467 int *arg3 = (int *) 0 ;
35468 int *arg4 = (int *) 0 ;
35469 int *arg5 = (int *) 0 ;
35470 int *arg6 = (int *) 0 ;
35471 wxFont *arg7 = (wxFont *) NULL ;
35472 void *argp1 = 0 ;
35473 int res1 = 0 ;
35474 bool temp2 = false ;
35475 int temp3 ;
35476 int res3 = SWIG_TMPOBJ ;
35477 int temp4 ;
35478 int res4 = SWIG_TMPOBJ ;
35479 int temp5 ;
35480 int res5 = SWIG_TMPOBJ ;
35481 int temp6 ;
35482 int res6 = SWIG_TMPOBJ ;
35483 void *argp7 = 0 ;
35484 int res7 = 0 ;
35485 PyObject * obj0 = 0 ;
35486 PyObject * obj1 = 0 ;
35487 PyObject * obj2 = 0 ;
35488 char * kwnames[] = {
35489 (char *) "self",(char *) "string",(char *) "font", NULL
35490 };
35491
35492 arg3 = &temp3;
35493 arg4 = &temp4;
35494 arg5 = &temp5;
35495 arg6 = &temp6;
35496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35498 if (!SWIG_IsOK(res1)) {
35499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35500 }
35501 arg1 = reinterpret_cast< wxWindow * >(argp1);
35502 {
35503 arg2 = wxString_in_helper(obj1);
35504 if (arg2 == NULL) SWIG_fail;
35505 temp2 = true;
35506 }
35507 if (obj2) {
35508 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35509 if (!SWIG_IsOK(res7)) {
35510 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35511 }
35512 arg7 = reinterpret_cast< wxFont * >(argp7);
35513 }
35514 {
35515 PyThreadState* __tstate = wxPyBeginAllowThreads();
35516 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35517 wxPyEndAllowThreads(__tstate);
35518 if (PyErr_Occurred()) SWIG_fail;
35519 }
35520 resultobj = SWIG_Py_Void();
35521 if (SWIG_IsTmpObj(res3)) {
35522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35523 } else {
35524 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35526 }
35527 if (SWIG_IsTmpObj(res4)) {
35528 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35529 } else {
35530 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35531 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35532 }
35533 if (SWIG_IsTmpObj(res5)) {
35534 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35535 } else {
35536 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35537 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35538 }
35539 if (SWIG_IsTmpObj(res6)) {
35540 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35541 } else {
35542 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35543 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35544 }
35545 {
35546 if (temp2)
35547 delete arg2;
35548 }
35549 return resultobj;
35550 fail:
35551 {
35552 if (temp2)
35553 delete arg2;
35554 }
35555 return NULL;
35556 }
35557
35558
35559 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35560 PyObject *resultobj = 0;
35561 wxWindow *arg1 = (wxWindow *) 0 ;
35562 int *arg2 = (int *) 0 ;
35563 int *arg3 = (int *) 0 ;
35564 void *argp1 = 0 ;
35565 int res1 = 0 ;
35566 int temp2 ;
35567 int res2 = 0 ;
35568 int temp3 ;
35569 int res3 = 0 ;
35570 PyObject * obj0 = 0 ;
35571 PyObject * obj1 = 0 ;
35572 PyObject * obj2 = 0 ;
35573 char * kwnames[] = {
35574 (char *) "self",(char *) "x",(char *) "y", NULL
35575 };
35576
35577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35579 if (!SWIG_IsOK(res1)) {
35580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35581 }
35582 arg1 = reinterpret_cast< wxWindow * >(argp1);
35583 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35584 int val;
35585 int ecode = SWIG_AsVal_int(obj1, &val);
35586 if (!SWIG_IsOK(ecode)) {
35587 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35588 }
35589 temp2 = static_cast< int >(val);
35590 arg2 = &temp2;
35591 res2 = SWIG_AddTmpMask(ecode);
35592 }
35593 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35594 int val;
35595 int ecode = SWIG_AsVal_int(obj2, &val);
35596 if (!SWIG_IsOK(ecode)) {
35597 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35598 }
35599 temp3 = static_cast< int >(val);
35600 arg3 = &temp3;
35601 res3 = SWIG_AddTmpMask(ecode);
35602 }
35603 {
35604 PyThreadState* __tstate = wxPyBeginAllowThreads();
35605 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35606 wxPyEndAllowThreads(__tstate);
35607 if (PyErr_Occurred()) SWIG_fail;
35608 }
35609 resultobj = SWIG_Py_Void();
35610 if (SWIG_IsTmpObj(res2)) {
35611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35612 } else {
35613 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35615 }
35616 if (SWIG_IsTmpObj(res3)) {
35617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35618 } else {
35619 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35621 }
35622 return resultobj;
35623 fail:
35624 return NULL;
35625 }
35626
35627
35628 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35629 PyObject *resultobj = 0;
35630 wxWindow *arg1 = (wxWindow *) 0 ;
35631 int *arg2 = (int *) 0 ;
35632 int *arg3 = (int *) 0 ;
35633 void *argp1 = 0 ;
35634 int res1 = 0 ;
35635 int temp2 ;
35636 int res2 = 0 ;
35637 int temp3 ;
35638 int res3 = 0 ;
35639 PyObject * obj0 = 0 ;
35640 PyObject * obj1 = 0 ;
35641 PyObject * obj2 = 0 ;
35642 char * kwnames[] = {
35643 (char *) "self",(char *) "x",(char *) "y", NULL
35644 };
35645
35646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35648 if (!SWIG_IsOK(res1)) {
35649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35650 }
35651 arg1 = reinterpret_cast< wxWindow * >(argp1);
35652 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35653 int val;
35654 int ecode = SWIG_AsVal_int(obj1, &val);
35655 if (!SWIG_IsOK(ecode)) {
35656 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35657 }
35658 temp2 = static_cast< int >(val);
35659 arg2 = &temp2;
35660 res2 = SWIG_AddTmpMask(ecode);
35661 }
35662 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35663 int val;
35664 int ecode = SWIG_AsVal_int(obj2, &val);
35665 if (!SWIG_IsOK(ecode)) {
35666 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35667 }
35668 temp3 = static_cast< int >(val);
35669 arg3 = &temp3;
35670 res3 = SWIG_AddTmpMask(ecode);
35671 }
35672 {
35673 PyThreadState* __tstate = wxPyBeginAllowThreads();
35674 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35675 wxPyEndAllowThreads(__tstate);
35676 if (PyErr_Occurred()) SWIG_fail;
35677 }
35678 resultobj = SWIG_Py_Void();
35679 if (SWIG_IsTmpObj(res2)) {
35680 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35681 } else {
35682 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35684 }
35685 if (SWIG_IsTmpObj(res3)) {
35686 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35687 } else {
35688 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35690 }
35691 return resultobj;
35692 fail:
35693 return NULL;
35694 }
35695
35696
35697 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35698 PyObject *resultobj = 0;
35699 wxWindow *arg1 = (wxWindow *) 0 ;
35700 wxPoint *arg2 = 0 ;
35701 wxPoint result;
35702 void *argp1 = 0 ;
35703 int res1 = 0 ;
35704 wxPoint temp2 ;
35705 PyObject * obj0 = 0 ;
35706 PyObject * obj1 = 0 ;
35707 char * kwnames[] = {
35708 (char *) "self",(char *) "pt", NULL
35709 };
35710
35711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35713 if (!SWIG_IsOK(res1)) {
35714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35715 }
35716 arg1 = reinterpret_cast< wxWindow * >(argp1);
35717 {
35718 arg2 = &temp2;
35719 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35720 }
35721 {
35722 PyThreadState* __tstate = wxPyBeginAllowThreads();
35723 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35724 wxPyEndAllowThreads(__tstate);
35725 if (PyErr_Occurred()) SWIG_fail;
35726 }
35727 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35728 return resultobj;
35729 fail:
35730 return NULL;
35731 }
35732
35733
35734 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35735 PyObject *resultobj = 0;
35736 wxWindow *arg1 = (wxWindow *) 0 ;
35737 wxPoint *arg2 = 0 ;
35738 wxPoint result;
35739 void *argp1 = 0 ;
35740 int res1 = 0 ;
35741 wxPoint temp2 ;
35742 PyObject * obj0 = 0 ;
35743 PyObject * obj1 = 0 ;
35744 char * kwnames[] = {
35745 (char *) "self",(char *) "pt", NULL
35746 };
35747
35748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35750 if (!SWIG_IsOK(res1)) {
35751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35752 }
35753 arg1 = reinterpret_cast< wxWindow * >(argp1);
35754 {
35755 arg2 = &temp2;
35756 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35757 }
35758 {
35759 PyThreadState* __tstate = wxPyBeginAllowThreads();
35760 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35761 wxPyEndAllowThreads(__tstate);
35762 if (PyErr_Occurred()) SWIG_fail;
35763 }
35764 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35765 return resultobj;
35766 fail:
35767 return NULL;
35768 }
35769
35770
35771 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35772 PyObject *resultobj = 0;
35773 wxWindow *arg1 = (wxWindow *) 0 ;
35774 int arg2 ;
35775 int arg3 ;
35776 wxHitTest result;
35777 void *argp1 = 0 ;
35778 int res1 = 0 ;
35779 int val2 ;
35780 int ecode2 = 0 ;
35781 int val3 ;
35782 int ecode3 = 0 ;
35783 PyObject * obj0 = 0 ;
35784 PyObject * obj1 = 0 ;
35785 PyObject * obj2 = 0 ;
35786 char * kwnames[] = {
35787 (char *) "self",(char *) "x",(char *) "y", NULL
35788 };
35789
35790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35792 if (!SWIG_IsOK(res1)) {
35793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35794 }
35795 arg1 = reinterpret_cast< wxWindow * >(argp1);
35796 ecode2 = SWIG_AsVal_int(obj1, &val2);
35797 if (!SWIG_IsOK(ecode2)) {
35798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35799 }
35800 arg2 = static_cast< int >(val2);
35801 ecode3 = SWIG_AsVal_int(obj2, &val3);
35802 if (!SWIG_IsOK(ecode3)) {
35803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35804 }
35805 arg3 = static_cast< int >(val3);
35806 {
35807 PyThreadState* __tstate = wxPyBeginAllowThreads();
35808 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35809 wxPyEndAllowThreads(__tstate);
35810 if (PyErr_Occurred()) SWIG_fail;
35811 }
35812 resultobj = SWIG_From_int(static_cast< int >(result));
35813 return resultobj;
35814 fail:
35815 return NULL;
35816 }
35817
35818
35819 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35820 PyObject *resultobj = 0;
35821 wxWindow *arg1 = (wxWindow *) 0 ;
35822 wxPoint *arg2 = 0 ;
35823 wxHitTest result;
35824 void *argp1 = 0 ;
35825 int res1 = 0 ;
35826 wxPoint temp2 ;
35827 PyObject * obj0 = 0 ;
35828 PyObject * obj1 = 0 ;
35829 char * kwnames[] = {
35830 (char *) "self",(char *) "pt", NULL
35831 };
35832
35833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35835 if (!SWIG_IsOK(res1)) {
35836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35837 }
35838 arg1 = reinterpret_cast< wxWindow * >(argp1);
35839 {
35840 arg2 = &temp2;
35841 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35842 }
35843 {
35844 PyThreadState* __tstate = wxPyBeginAllowThreads();
35845 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35846 wxPyEndAllowThreads(__tstate);
35847 if (PyErr_Occurred()) SWIG_fail;
35848 }
35849 resultobj = SWIG_From_int(static_cast< int >(result));
35850 return resultobj;
35851 fail:
35852 return NULL;
35853 }
35854
35855
35856 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35857 PyObject *resultobj = 0;
35858 wxWindow *arg1 = (wxWindow *) 0 ;
35859 long arg2 ;
35860 wxBorder result;
35861 void *argp1 = 0 ;
35862 int res1 = 0 ;
35863 long val2 ;
35864 int ecode2 = 0 ;
35865
35866 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35868 if (!SWIG_IsOK(res1)) {
35869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35870 }
35871 arg1 = reinterpret_cast< wxWindow * >(argp1);
35872 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35873 if (!SWIG_IsOK(ecode2)) {
35874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35875 }
35876 arg2 = static_cast< long >(val2);
35877 {
35878 PyThreadState* __tstate = wxPyBeginAllowThreads();
35879 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35880 wxPyEndAllowThreads(__tstate);
35881 if (PyErr_Occurred()) SWIG_fail;
35882 }
35883 resultobj = SWIG_From_int(static_cast< int >(result));
35884 return resultobj;
35885 fail:
35886 return NULL;
35887 }
35888
35889
35890 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35891 PyObject *resultobj = 0;
35892 wxWindow *arg1 = (wxWindow *) 0 ;
35893 wxBorder result;
35894 void *argp1 = 0 ;
35895 int res1 = 0 ;
35896
35897 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35899 if (!SWIG_IsOK(res1)) {
35900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35901 }
35902 arg1 = reinterpret_cast< wxWindow * >(argp1);
35903 {
35904 PyThreadState* __tstate = wxPyBeginAllowThreads();
35905 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35906 wxPyEndAllowThreads(__tstate);
35907 if (PyErr_Occurred()) SWIG_fail;
35908 }
35909 resultobj = SWIG_From_int(static_cast< int >(result));
35910 return resultobj;
35911 fail:
35912 return NULL;
35913 }
35914
35915
35916 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35917 int argc;
35918 PyObject *argv[3];
35919
35920 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35921 --argc;
35922 if (argc == 1) {
35923 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35924 }
35925 if (argc == 2) {
35926 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35927 }
35928
35929 fail:
35930 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35931 return NULL;
35932 }
35933
35934
35935 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35936 PyObject *resultobj = 0;
35937 wxWindow *arg1 = (wxWindow *) 0 ;
35938 long arg2 = (long) wxUPDATE_UI_NONE ;
35939 void *argp1 = 0 ;
35940 int res1 = 0 ;
35941 long val2 ;
35942 int ecode2 = 0 ;
35943 PyObject * obj0 = 0 ;
35944 PyObject * obj1 = 0 ;
35945 char * kwnames[] = {
35946 (char *) "self",(char *) "flags", NULL
35947 };
35948
35949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35951 if (!SWIG_IsOK(res1)) {
35952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35953 }
35954 arg1 = reinterpret_cast< wxWindow * >(argp1);
35955 if (obj1) {
35956 ecode2 = SWIG_AsVal_long(obj1, &val2);
35957 if (!SWIG_IsOK(ecode2)) {
35958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35959 }
35960 arg2 = static_cast< long >(val2);
35961 }
35962 {
35963 PyThreadState* __tstate = wxPyBeginAllowThreads();
35964 (arg1)->UpdateWindowUI(arg2);
35965 wxPyEndAllowThreads(__tstate);
35966 if (PyErr_Occurred()) SWIG_fail;
35967 }
35968 resultobj = SWIG_Py_Void();
35969 return resultobj;
35970 fail:
35971 return NULL;
35972 }
35973
35974
35975 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35976 PyObject *resultobj = 0;
35977 wxWindow *arg1 = (wxWindow *) 0 ;
35978 wxMenu *arg2 = (wxMenu *) 0 ;
35979 int arg3 = (int) -1 ;
35980 int arg4 = (int) -1 ;
35981 bool result;
35982 void *argp1 = 0 ;
35983 int res1 = 0 ;
35984 void *argp2 = 0 ;
35985 int res2 = 0 ;
35986 int val3 ;
35987 int ecode3 = 0 ;
35988 int val4 ;
35989 int ecode4 = 0 ;
35990 PyObject * obj0 = 0 ;
35991 PyObject * obj1 = 0 ;
35992 PyObject * obj2 = 0 ;
35993 PyObject * obj3 = 0 ;
35994 char * kwnames[] = {
35995 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35996 };
35997
35998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36000 if (!SWIG_IsOK(res1)) {
36001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36002 }
36003 arg1 = reinterpret_cast< wxWindow * >(argp1);
36004 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36005 if (!SWIG_IsOK(res2)) {
36006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36007 }
36008 arg2 = reinterpret_cast< wxMenu * >(argp2);
36009 if (obj2) {
36010 ecode3 = SWIG_AsVal_int(obj2, &val3);
36011 if (!SWIG_IsOK(ecode3)) {
36012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36013 }
36014 arg3 = static_cast< int >(val3);
36015 }
36016 if (obj3) {
36017 ecode4 = SWIG_AsVal_int(obj3, &val4);
36018 if (!SWIG_IsOK(ecode4)) {
36019 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36020 }
36021 arg4 = static_cast< int >(val4);
36022 }
36023 {
36024 PyThreadState* __tstate = wxPyBeginAllowThreads();
36025 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36026 wxPyEndAllowThreads(__tstate);
36027 if (PyErr_Occurred()) SWIG_fail;
36028 }
36029 {
36030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36031 }
36032 return resultobj;
36033 fail:
36034 return NULL;
36035 }
36036
36037
36038 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36039 PyObject *resultobj = 0;
36040 wxWindow *arg1 = (wxWindow *) 0 ;
36041 wxMenu *arg2 = (wxMenu *) 0 ;
36042 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36043 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36044 bool result;
36045 void *argp1 = 0 ;
36046 int res1 = 0 ;
36047 void *argp2 = 0 ;
36048 int res2 = 0 ;
36049 wxPoint temp3 ;
36050 PyObject * obj0 = 0 ;
36051 PyObject * obj1 = 0 ;
36052 PyObject * obj2 = 0 ;
36053 char * kwnames[] = {
36054 (char *) "self",(char *) "menu",(char *) "pos", NULL
36055 };
36056
36057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36059 if (!SWIG_IsOK(res1)) {
36060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36061 }
36062 arg1 = reinterpret_cast< wxWindow * >(argp1);
36063 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36064 if (!SWIG_IsOK(res2)) {
36065 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36066 }
36067 arg2 = reinterpret_cast< wxMenu * >(argp2);
36068 if (obj2) {
36069 {
36070 arg3 = &temp3;
36071 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36072 }
36073 }
36074 {
36075 PyThreadState* __tstate = wxPyBeginAllowThreads();
36076 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36077 wxPyEndAllowThreads(__tstate);
36078 if (PyErr_Occurred()) SWIG_fail;
36079 }
36080 {
36081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36082 }
36083 return resultobj;
36084 fail:
36085 return NULL;
36086 }
36087
36088
36089 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36090 PyObject *resultobj = 0;
36091 wxWindow *arg1 = (wxWindow *) 0 ;
36092 long result;
36093 void *argp1 = 0 ;
36094 int res1 = 0 ;
36095 PyObject *swig_obj[1] ;
36096
36097 if (!args) SWIG_fail;
36098 swig_obj[0] = args;
36099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36100 if (!SWIG_IsOK(res1)) {
36101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36102 }
36103 arg1 = reinterpret_cast< wxWindow * >(argp1);
36104 {
36105 PyThreadState* __tstate = wxPyBeginAllowThreads();
36106 result = (long)wxWindow_GetHandle(arg1);
36107 wxPyEndAllowThreads(__tstate);
36108 if (PyErr_Occurred()) SWIG_fail;
36109 }
36110 resultobj = SWIG_From_long(static_cast< long >(result));
36111 return resultobj;
36112 fail:
36113 return NULL;
36114 }
36115
36116
36117 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36118 PyObject *resultobj = 0;
36119 wxWindow *arg1 = (wxWindow *) 0 ;
36120 long arg2 ;
36121 void *argp1 = 0 ;
36122 int res1 = 0 ;
36123 long val2 ;
36124 int ecode2 = 0 ;
36125 PyObject * obj0 = 0 ;
36126 PyObject * obj1 = 0 ;
36127 char * kwnames[] = {
36128 (char *) "self",(char *) "handle", NULL
36129 };
36130
36131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36133 if (!SWIG_IsOK(res1)) {
36134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36135 }
36136 arg1 = reinterpret_cast< wxWindow * >(argp1);
36137 ecode2 = SWIG_AsVal_long(obj1, &val2);
36138 if (!SWIG_IsOK(ecode2)) {
36139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36140 }
36141 arg2 = static_cast< long >(val2);
36142 {
36143 PyThreadState* __tstate = wxPyBeginAllowThreads();
36144 wxWindow_AssociateHandle(arg1,arg2);
36145 wxPyEndAllowThreads(__tstate);
36146 if (PyErr_Occurred()) SWIG_fail;
36147 }
36148 resultobj = SWIG_Py_Void();
36149 return resultobj;
36150 fail:
36151 return NULL;
36152 }
36153
36154
36155 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36156 PyObject *resultobj = 0;
36157 wxWindow *arg1 = (wxWindow *) 0 ;
36158 void *argp1 = 0 ;
36159 int res1 = 0 ;
36160 PyObject *swig_obj[1] ;
36161
36162 if (!args) SWIG_fail;
36163 swig_obj[0] = args;
36164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36165 if (!SWIG_IsOK(res1)) {
36166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36167 }
36168 arg1 = reinterpret_cast< wxWindow * >(argp1);
36169 {
36170 PyThreadState* __tstate = wxPyBeginAllowThreads();
36171 (arg1)->DissociateHandle();
36172 wxPyEndAllowThreads(__tstate);
36173 if (PyErr_Occurred()) SWIG_fail;
36174 }
36175 resultobj = SWIG_Py_Void();
36176 return resultobj;
36177 fail:
36178 return NULL;
36179 }
36180
36181
36182 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36183 PyObject *resultobj = 0;
36184 wxWindow *arg1 = (wxWindow *) 0 ;
36185 int arg2 ;
36186 bool result;
36187 void *argp1 = 0 ;
36188 int res1 = 0 ;
36189 int val2 ;
36190 int ecode2 = 0 ;
36191 PyObject * obj0 = 0 ;
36192 PyObject * obj1 = 0 ;
36193 char * kwnames[] = {
36194 (char *) "self",(char *) "orient", NULL
36195 };
36196
36197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) 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_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
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_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36206 }
36207 arg2 = static_cast< int >(val2);
36208 {
36209 PyThreadState* __tstate = wxPyBeginAllowThreads();
36210 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36211 wxPyEndAllowThreads(__tstate);
36212 if (PyErr_Occurred()) SWIG_fail;
36213 }
36214 {
36215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36216 }
36217 return resultobj;
36218 fail:
36219 return NULL;
36220 }
36221
36222
36223 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36224 PyObject *resultobj = 0;
36225 wxWindow *arg1 = (wxWindow *) 0 ;
36226 int arg2 ;
36227 int arg3 ;
36228 int arg4 ;
36229 int arg5 ;
36230 bool arg6 = (bool) true ;
36231 void *argp1 = 0 ;
36232 int res1 = 0 ;
36233 int val2 ;
36234 int ecode2 = 0 ;
36235 int val3 ;
36236 int ecode3 = 0 ;
36237 int val4 ;
36238 int ecode4 = 0 ;
36239 int val5 ;
36240 int ecode5 = 0 ;
36241 bool val6 ;
36242 int ecode6 = 0 ;
36243 PyObject * obj0 = 0 ;
36244 PyObject * obj1 = 0 ;
36245 PyObject * obj2 = 0 ;
36246 PyObject * obj3 = 0 ;
36247 PyObject * obj4 = 0 ;
36248 PyObject * obj5 = 0 ;
36249 char * kwnames[] = {
36250 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36251 };
36252
36253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36255 if (!SWIG_IsOK(res1)) {
36256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36257 }
36258 arg1 = reinterpret_cast< wxWindow * >(argp1);
36259 ecode2 = SWIG_AsVal_int(obj1, &val2);
36260 if (!SWIG_IsOK(ecode2)) {
36261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36262 }
36263 arg2 = static_cast< int >(val2);
36264 ecode3 = SWIG_AsVal_int(obj2, &val3);
36265 if (!SWIG_IsOK(ecode3)) {
36266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36267 }
36268 arg3 = static_cast< int >(val3);
36269 ecode4 = SWIG_AsVal_int(obj3, &val4);
36270 if (!SWIG_IsOK(ecode4)) {
36271 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36272 }
36273 arg4 = static_cast< int >(val4);
36274 ecode5 = SWIG_AsVal_int(obj4, &val5);
36275 if (!SWIG_IsOK(ecode5)) {
36276 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36277 }
36278 arg5 = static_cast< int >(val5);
36279 if (obj5) {
36280 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36281 if (!SWIG_IsOK(ecode6)) {
36282 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36283 }
36284 arg6 = static_cast< bool >(val6);
36285 }
36286 {
36287 PyThreadState* __tstate = wxPyBeginAllowThreads();
36288 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36289 wxPyEndAllowThreads(__tstate);
36290 if (PyErr_Occurred()) SWIG_fail;
36291 }
36292 resultobj = SWIG_Py_Void();
36293 return resultobj;
36294 fail:
36295 return NULL;
36296 }
36297
36298
36299 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36300 PyObject *resultobj = 0;
36301 wxWindow *arg1 = (wxWindow *) 0 ;
36302 int arg2 ;
36303 int arg3 ;
36304 bool arg4 = (bool) true ;
36305 void *argp1 = 0 ;
36306 int res1 = 0 ;
36307 int val2 ;
36308 int ecode2 = 0 ;
36309 int val3 ;
36310 int ecode3 = 0 ;
36311 bool val4 ;
36312 int ecode4 = 0 ;
36313 PyObject * obj0 = 0 ;
36314 PyObject * obj1 = 0 ;
36315 PyObject * obj2 = 0 ;
36316 PyObject * obj3 = 0 ;
36317 char * kwnames[] = {
36318 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36319 };
36320
36321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36323 if (!SWIG_IsOK(res1)) {
36324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36325 }
36326 arg1 = reinterpret_cast< wxWindow * >(argp1);
36327 ecode2 = SWIG_AsVal_int(obj1, &val2);
36328 if (!SWIG_IsOK(ecode2)) {
36329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36330 }
36331 arg2 = static_cast< int >(val2);
36332 ecode3 = SWIG_AsVal_int(obj2, &val3);
36333 if (!SWIG_IsOK(ecode3)) {
36334 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36335 }
36336 arg3 = static_cast< int >(val3);
36337 if (obj3) {
36338 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36339 if (!SWIG_IsOK(ecode4)) {
36340 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36341 }
36342 arg4 = static_cast< bool >(val4);
36343 }
36344 {
36345 PyThreadState* __tstate = wxPyBeginAllowThreads();
36346 (arg1)->SetScrollPos(arg2,arg3,arg4);
36347 wxPyEndAllowThreads(__tstate);
36348 if (PyErr_Occurred()) SWIG_fail;
36349 }
36350 resultobj = SWIG_Py_Void();
36351 return resultobj;
36352 fail:
36353 return NULL;
36354 }
36355
36356
36357 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36358 PyObject *resultobj = 0;
36359 wxWindow *arg1 = (wxWindow *) 0 ;
36360 int arg2 ;
36361 int result;
36362 void *argp1 = 0 ;
36363 int res1 = 0 ;
36364 int val2 ;
36365 int ecode2 = 0 ;
36366 PyObject * obj0 = 0 ;
36367 PyObject * obj1 = 0 ;
36368 char * kwnames[] = {
36369 (char *) "self",(char *) "orientation", NULL
36370 };
36371
36372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) 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_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
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_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36381 }
36382 arg2 = static_cast< int >(val2);
36383 {
36384 PyThreadState* __tstate = wxPyBeginAllowThreads();
36385 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36386 wxPyEndAllowThreads(__tstate);
36387 if (PyErr_Occurred()) SWIG_fail;
36388 }
36389 resultobj = SWIG_From_int(static_cast< int >(result));
36390 return resultobj;
36391 fail:
36392 return NULL;
36393 }
36394
36395
36396 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36397 PyObject *resultobj = 0;
36398 wxWindow *arg1 = (wxWindow *) 0 ;
36399 int arg2 ;
36400 int result;
36401 void *argp1 = 0 ;
36402 int res1 = 0 ;
36403 int val2 ;
36404 int ecode2 = 0 ;
36405 PyObject * obj0 = 0 ;
36406 PyObject * obj1 = 0 ;
36407 char * kwnames[] = {
36408 (char *) "self",(char *) "orientation", NULL
36409 };
36410
36411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36413 if (!SWIG_IsOK(res1)) {
36414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36415 }
36416 arg1 = reinterpret_cast< wxWindow * >(argp1);
36417 ecode2 = SWIG_AsVal_int(obj1, &val2);
36418 if (!SWIG_IsOK(ecode2)) {
36419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36420 }
36421 arg2 = static_cast< int >(val2);
36422 {
36423 PyThreadState* __tstate = wxPyBeginAllowThreads();
36424 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36425 wxPyEndAllowThreads(__tstate);
36426 if (PyErr_Occurred()) SWIG_fail;
36427 }
36428 resultobj = SWIG_From_int(static_cast< int >(result));
36429 return resultobj;
36430 fail:
36431 return NULL;
36432 }
36433
36434
36435 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36436 PyObject *resultobj = 0;
36437 wxWindow *arg1 = (wxWindow *) 0 ;
36438 int arg2 ;
36439 int result;
36440 void *argp1 = 0 ;
36441 int res1 = 0 ;
36442 int val2 ;
36443 int ecode2 = 0 ;
36444 PyObject * obj0 = 0 ;
36445 PyObject * obj1 = 0 ;
36446 char * kwnames[] = {
36447 (char *) "self",(char *) "orientation", NULL
36448 };
36449
36450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36452 if (!SWIG_IsOK(res1)) {
36453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36454 }
36455 arg1 = reinterpret_cast< wxWindow * >(argp1);
36456 ecode2 = SWIG_AsVal_int(obj1, &val2);
36457 if (!SWIG_IsOK(ecode2)) {
36458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36459 }
36460 arg2 = static_cast< int >(val2);
36461 {
36462 PyThreadState* __tstate = wxPyBeginAllowThreads();
36463 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36464 wxPyEndAllowThreads(__tstate);
36465 if (PyErr_Occurred()) SWIG_fail;
36466 }
36467 resultobj = SWIG_From_int(static_cast< int >(result));
36468 return resultobj;
36469 fail:
36470 return NULL;
36471 }
36472
36473
36474 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36475 PyObject *resultobj = 0;
36476 wxWindow *arg1 = (wxWindow *) 0 ;
36477 int arg2 ;
36478 int arg3 ;
36479 wxRect *arg4 = (wxRect *) NULL ;
36480 void *argp1 = 0 ;
36481 int res1 = 0 ;
36482 int val2 ;
36483 int ecode2 = 0 ;
36484 int val3 ;
36485 int ecode3 = 0 ;
36486 void *argp4 = 0 ;
36487 int res4 = 0 ;
36488 PyObject * obj0 = 0 ;
36489 PyObject * obj1 = 0 ;
36490 PyObject * obj2 = 0 ;
36491 PyObject * obj3 = 0 ;
36492 char * kwnames[] = {
36493 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36494 };
36495
36496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36498 if (!SWIG_IsOK(res1)) {
36499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36500 }
36501 arg1 = reinterpret_cast< wxWindow * >(argp1);
36502 ecode2 = SWIG_AsVal_int(obj1, &val2);
36503 if (!SWIG_IsOK(ecode2)) {
36504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36505 }
36506 arg2 = static_cast< int >(val2);
36507 ecode3 = SWIG_AsVal_int(obj2, &val3);
36508 if (!SWIG_IsOK(ecode3)) {
36509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36510 }
36511 arg3 = static_cast< int >(val3);
36512 if (obj3) {
36513 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36514 if (!SWIG_IsOK(res4)) {
36515 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36516 }
36517 arg4 = reinterpret_cast< wxRect * >(argp4);
36518 }
36519 {
36520 PyThreadState* __tstate = wxPyBeginAllowThreads();
36521 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36522 wxPyEndAllowThreads(__tstate);
36523 if (PyErr_Occurred()) SWIG_fail;
36524 }
36525 resultobj = SWIG_Py_Void();
36526 return resultobj;
36527 fail:
36528 return NULL;
36529 }
36530
36531
36532 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36533 PyObject *resultobj = 0;
36534 wxWindow *arg1 = (wxWindow *) 0 ;
36535 int arg2 ;
36536 bool result;
36537 void *argp1 = 0 ;
36538 int res1 = 0 ;
36539 int val2 ;
36540 int ecode2 = 0 ;
36541 PyObject * obj0 = 0 ;
36542 PyObject * obj1 = 0 ;
36543 char * kwnames[] = {
36544 (char *) "self",(char *) "lines", NULL
36545 };
36546
36547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36549 if (!SWIG_IsOK(res1)) {
36550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36551 }
36552 arg1 = reinterpret_cast< wxWindow * >(argp1);
36553 ecode2 = SWIG_AsVal_int(obj1, &val2);
36554 if (!SWIG_IsOK(ecode2)) {
36555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36556 }
36557 arg2 = static_cast< int >(val2);
36558 {
36559 PyThreadState* __tstate = wxPyBeginAllowThreads();
36560 result = (bool)(arg1)->ScrollLines(arg2);
36561 wxPyEndAllowThreads(__tstate);
36562 if (PyErr_Occurred()) SWIG_fail;
36563 }
36564 {
36565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36566 }
36567 return resultobj;
36568 fail:
36569 return NULL;
36570 }
36571
36572
36573 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36574 PyObject *resultobj = 0;
36575 wxWindow *arg1 = (wxWindow *) 0 ;
36576 int arg2 ;
36577 bool result;
36578 void *argp1 = 0 ;
36579 int res1 = 0 ;
36580 int val2 ;
36581 int ecode2 = 0 ;
36582 PyObject * obj0 = 0 ;
36583 PyObject * obj1 = 0 ;
36584 char * kwnames[] = {
36585 (char *) "self",(char *) "pages", NULL
36586 };
36587
36588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36590 if (!SWIG_IsOK(res1)) {
36591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36592 }
36593 arg1 = reinterpret_cast< wxWindow * >(argp1);
36594 ecode2 = SWIG_AsVal_int(obj1, &val2);
36595 if (!SWIG_IsOK(ecode2)) {
36596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36597 }
36598 arg2 = static_cast< int >(val2);
36599 {
36600 PyThreadState* __tstate = wxPyBeginAllowThreads();
36601 result = (bool)(arg1)->ScrollPages(arg2);
36602 wxPyEndAllowThreads(__tstate);
36603 if (PyErr_Occurred()) SWIG_fail;
36604 }
36605 {
36606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36607 }
36608 return resultobj;
36609 fail:
36610 return NULL;
36611 }
36612
36613
36614 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36615 PyObject *resultobj = 0;
36616 wxWindow *arg1 = (wxWindow *) 0 ;
36617 bool result;
36618 void *argp1 = 0 ;
36619 int res1 = 0 ;
36620 PyObject *swig_obj[1] ;
36621
36622 if (!args) SWIG_fail;
36623 swig_obj[0] = args;
36624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36625 if (!SWIG_IsOK(res1)) {
36626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36627 }
36628 arg1 = reinterpret_cast< wxWindow * >(argp1);
36629 {
36630 PyThreadState* __tstate = wxPyBeginAllowThreads();
36631 result = (bool)(arg1)->LineUp();
36632 wxPyEndAllowThreads(__tstate);
36633 if (PyErr_Occurred()) SWIG_fail;
36634 }
36635 {
36636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36637 }
36638 return resultobj;
36639 fail:
36640 return NULL;
36641 }
36642
36643
36644 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36645 PyObject *resultobj = 0;
36646 wxWindow *arg1 = (wxWindow *) 0 ;
36647 bool result;
36648 void *argp1 = 0 ;
36649 int res1 = 0 ;
36650 PyObject *swig_obj[1] ;
36651
36652 if (!args) SWIG_fail;
36653 swig_obj[0] = args;
36654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36655 if (!SWIG_IsOK(res1)) {
36656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36657 }
36658 arg1 = reinterpret_cast< wxWindow * >(argp1);
36659 {
36660 PyThreadState* __tstate = wxPyBeginAllowThreads();
36661 result = (bool)(arg1)->LineDown();
36662 wxPyEndAllowThreads(__tstate);
36663 if (PyErr_Occurred()) SWIG_fail;
36664 }
36665 {
36666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36667 }
36668 return resultobj;
36669 fail:
36670 return NULL;
36671 }
36672
36673
36674 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36675 PyObject *resultobj = 0;
36676 wxWindow *arg1 = (wxWindow *) 0 ;
36677 bool result;
36678 void *argp1 = 0 ;
36679 int res1 = 0 ;
36680 PyObject *swig_obj[1] ;
36681
36682 if (!args) SWIG_fail;
36683 swig_obj[0] = args;
36684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36685 if (!SWIG_IsOK(res1)) {
36686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36687 }
36688 arg1 = reinterpret_cast< wxWindow * >(argp1);
36689 {
36690 PyThreadState* __tstate = wxPyBeginAllowThreads();
36691 result = (bool)(arg1)->PageUp();
36692 wxPyEndAllowThreads(__tstate);
36693 if (PyErr_Occurred()) SWIG_fail;
36694 }
36695 {
36696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36697 }
36698 return resultobj;
36699 fail:
36700 return NULL;
36701 }
36702
36703
36704 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36705 PyObject *resultobj = 0;
36706 wxWindow *arg1 = (wxWindow *) 0 ;
36707 bool result;
36708 void *argp1 = 0 ;
36709 int res1 = 0 ;
36710 PyObject *swig_obj[1] ;
36711
36712 if (!args) SWIG_fail;
36713 swig_obj[0] = args;
36714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36715 if (!SWIG_IsOK(res1)) {
36716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36717 }
36718 arg1 = reinterpret_cast< wxWindow * >(argp1);
36719 {
36720 PyThreadState* __tstate = wxPyBeginAllowThreads();
36721 result = (bool)(arg1)->PageDown();
36722 wxPyEndAllowThreads(__tstate);
36723 if (PyErr_Occurred()) SWIG_fail;
36724 }
36725 {
36726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36727 }
36728 return resultobj;
36729 fail:
36730 return NULL;
36731 }
36732
36733
36734 SWIGINTERN PyObject *_wrap_Window_SetHelpText(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 *) "text", NULL
36745 };
36746
36747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",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_SetHelpText" "', 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)->SetHelpText((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_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36780 PyObject *resultobj = 0;
36781 wxWindow *arg1 = (wxWindow *) 0 ;
36782 wxString *arg2 = 0 ;
36783 void *argp1 = 0 ;
36784 int res1 = 0 ;
36785 bool temp2 = false ;
36786 PyObject * obj0 = 0 ;
36787 PyObject * obj1 = 0 ;
36788 char * kwnames[] = {
36789 (char *) "self",(char *) "text", NULL
36790 };
36791
36792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",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_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36796 }
36797 arg1 = reinterpret_cast< wxWindow * >(argp1);
36798 {
36799 arg2 = wxString_in_helper(obj1);
36800 if (arg2 == NULL) SWIG_fail;
36801 temp2 = true;
36802 }
36803 {
36804 PyThreadState* __tstate = wxPyBeginAllowThreads();
36805 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36806 wxPyEndAllowThreads(__tstate);
36807 if (PyErr_Occurred()) SWIG_fail;
36808 }
36809 resultobj = SWIG_Py_Void();
36810 {
36811 if (temp2)
36812 delete arg2;
36813 }
36814 return resultobj;
36815 fail:
36816 {
36817 if (temp2)
36818 delete arg2;
36819 }
36820 return NULL;
36821 }
36822
36823
36824 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36825 PyObject *resultobj = 0;
36826 wxWindow *arg1 = (wxWindow *) 0 ;
36827 wxString result;
36828 void *argp1 = 0 ;
36829 int res1 = 0 ;
36830 PyObject *swig_obj[1] ;
36831
36832 if (!args) SWIG_fail;
36833 swig_obj[0] = args;
36834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36835 if (!SWIG_IsOK(res1)) {
36836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36837 }
36838 arg1 = reinterpret_cast< wxWindow * >(argp1);
36839 {
36840 PyThreadState* __tstate = wxPyBeginAllowThreads();
36841 result = ((wxWindow const *)arg1)->GetHelpText();
36842 wxPyEndAllowThreads(__tstate);
36843 if (PyErr_Occurred()) SWIG_fail;
36844 }
36845 {
36846 #if wxUSE_UNICODE
36847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36848 #else
36849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36850 #endif
36851 }
36852 return resultobj;
36853 fail:
36854 return NULL;
36855 }
36856
36857
36858 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36859 PyObject *resultobj = 0;
36860 wxWindow *arg1 = (wxWindow *) 0 ;
36861 wxString *arg2 = 0 ;
36862 void *argp1 = 0 ;
36863 int res1 = 0 ;
36864 bool temp2 = false ;
36865 PyObject * obj0 = 0 ;
36866 PyObject * obj1 = 0 ;
36867 char * kwnames[] = {
36868 (char *) "self",(char *) "tip", NULL
36869 };
36870
36871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36873 if (!SWIG_IsOK(res1)) {
36874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36875 }
36876 arg1 = reinterpret_cast< wxWindow * >(argp1);
36877 {
36878 arg2 = wxString_in_helper(obj1);
36879 if (arg2 == NULL) SWIG_fail;
36880 temp2 = true;
36881 }
36882 {
36883 PyThreadState* __tstate = wxPyBeginAllowThreads();
36884 (arg1)->SetToolTip((wxString const &)*arg2);
36885 wxPyEndAllowThreads(__tstate);
36886 if (PyErr_Occurred()) SWIG_fail;
36887 }
36888 resultobj = SWIG_Py_Void();
36889 {
36890 if (temp2)
36891 delete arg2;
36892 }
36893 return resultobj;
36894 fail:
36895 {
36896 if (temp2)
36897 delete arg2;
36898 }
36899 return NULL;
36900 }
36901
36902
36903 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36904 PyObject *resultobj = 0;
36905 wxWindow *arg1 = (wxWindow *) 0 ;
36906 wxToolTip *arg2 = (wxToolTip *) 0 ;
36907 void *argp1 = 0 ;
36908 int res1 = 0 ;
36909 int res2 = 0 ;
36910 PyObject * obj0 = 0 ;
36911 PyObject * obj1 = 0 ;
36912 char * kwnames[] = {
36913 (char *) "self",(char *) "tip", NULL
36914 };
36915
36916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36918 if (!SWIG_IsOK(res1)) {
36919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36920 }
36921 arg1 = reinterpret_cast< wxWindow * >(argp1);
36922 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36923 if (!SWIG_IsOK(res2)) {
36924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36925 }
36926 {
36927 PyThreadState* __tstate = wxPyBeginAllowThreads();
36928 (arg1)->SetToolTip(arg2);
36929 wxPyEndAllowThreads(__tstate);
36930 if (PyErr_Occurred()) SWIG_fail;
36931 }
36932 resultobj = SWIG_Py_Void();
36933 return resultobj;
36934 fail:
36935 return NULL;
36936 }
36937
36938
36939 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36940 PyObject *resultobj = 0;
36941 wxWindow *arg1 = (wxWindow *) 0 ;
36942 wxToolTip *result = 0 ;
36943 void *argp1 = 0 ;
36944 int res1 = 0 ;
36945 PyObject *swig_obj[1] ;
36946
36947 if (!args) SWIG_fail;
36948 swig_obj[0] = args;
36949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36950 if (!SWIG_IsOK(res1)) {
36951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36952 }
36953 arg1 = reinterpret_cast< wxWindow * >(argp1);
36954 {
36955 PyThreadState* __tstate = wxPyBeginAllowThreads();
36956 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36957 wxPyEndAllowThreads(__tstate);
36958 if (PyErr_Occurred()) SWIG_fail;
36959 }
36960 {
36961 resultobj = wxPyMake_wxObject(result, (bool)0);
36962 }
36963 return resultobj;
36964 fail:
36965 return NULL;
36966 }
36967
36968
36969 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36970 PyObject *resultobj = 0;
36971 wxWindow *arg1 = (wxWindow *) 0 ;
36972 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36973 void *argp1 = 0 ;
36974 int res1 = 0 ;
36975 int res2 = 0 ;
36976 PyObject * obj0 = 0 ;
36977 PyObject * obj1 = 0 ;
36978 char * kwnames[] = {
36979 (char *) "self",(char *) "dropTarget", NULL
36980 };
36981
36982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36984 if (!SWIG_IsOK(res1)) {
36985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36986 }
36987 arg1 = reinterpret_cast< wxWindow * >(argp1);
36988 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36989 if (!SWIG_IsOK(res2)) {
36990 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36991 }
36992 {
36993 PyThreadState* __tstate = wxPyBeginAllowThreads();
36994 (arg1)->SetDropTarget(arg2);
36995 wxPyEndAllowThreads(__tstate);
36996 if (PyErr_Occurred()) SWIG_fail;
36997 }
36998 resultobj = SWIG_Py_Void();
36999 return resultobj;
37000 fail:
37001 return NULL;
37002 }
37003
37004
37005 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37006 PyObject *resultobj = 0;
37007 wxWindow *arg1 = (wxWindow *) 0 ;
37008 wxPyDropTarget *result = 0 ;
37009 void *argp1 = 0 ;
37010 int res1 = 0 ;
37011 PyObject *swig_obj[1] ;
37012
37013 if (!args) SWIG_fail;
37014 swig_obj[0] = args;
37015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37016 if (!SWIG_IsOK(res1)) {
37017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37018 }
37019 arg1 = reinterpret_cast< wxWindow * >(argp1);
37020 {
37021 PyThreadState* __tstate = wxPyBeginAllowThreads();
37022 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37023 wxPyEndAllowThreads(__tstate);
37024 if (PyErr_Occurred()) SWIG_fail;
37025 }
37026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37027 return resultobj;
37028 fail:
37029 return NULL;
37030 }
37031
37032
37033 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37034 PyObject *resultobj = 0;
37035 wxWindow *arg1 = (wxWindow *) 0 ;
37036 bool arg2 ;
37037 void *argp1 = 0 ;
37038 int res1 = 0 ;
37039 bool val2 ;
37040 int ecode2 = 0 ;
37041 PyObject * obj0 = 0 ;
37042 PyObject * obj1 = 0 ;
37043 char * kwnames[] = {
37044 (char *) "self",(char *) "accept", NULL
37045 };
37046
37047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37049 if (!SWIG_IsOK(res1)) {
37050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37051 }
37052 arg1 = reinterpret_cast< wxWindow * >(argp1);
37053 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37054 if (!SWIG_IsOK(ecode2)) {
37055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37056 }
37057 arg2 = static_cast< bool >(val2);
37058 {
37059 PyThreadState* __tstate = wxPyBeginAllowThreads();
37060 wxWindow_DragAcceptFiles(arg1,arg2);
37061 wxPyEndAllowThreads(__tstate);
37062 if (PyErr_Occurred()) SWIG_fail;
37063 }
37064 resultobj = SWIG_Py_Void();
37065 return resultobj;
37066 fail:
37067 return NULL;
37068 }
37069
37070
37071 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37072 PyObject *resultobj = 0;
37073 wxWindow *arg1 = (wxWindow *) 0 ;
37074 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37075 void *argp1 = 0 ;
37076 int res1 = 0 ;
37077 int res2 = 0 ;
37078 PyObject * obj0 = 0 ;
37079 PyObject * obj1 = 0 ;
37080 char * kwnames[] = {
37081 (char *) "self",(char *) "constraints", NULL
37082 };
37083
37084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37086 if (!SWIG_IsOK(res1)) {
37087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37088 }
37089 arg1 = reinterpret_cast< wxWindow * >(argp1);
37090 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37091 if (!SWIG_IsOK(res2)) {
37092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37093 }
37094 {
37095 PyThreadState* __tstate = wxPyBeginAllowThreads();
37096 (arg1)->SetConstraints(arg2);
37097 wxPyEndAllowThreads(__tstate);
37098 if (PyErr_Occurred()) SWIG_fail;
37099 }
37100 resultobj = SWIG_Py_Void();
37101 return resultobj;
37102 fail:
37103 return NULL;
37104 }
37105
37106
37107 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37108 PyObject *resultobj = 0;
37109 wxWindow *arg1 = (wxWindow *) 0 ;
37110 wxLayoutConstraints *result = 0 ;
37111 void *argp1 = 0 ;
37112 int res1 = 0 ;
37113 PyObject *swig_obj[1] ;
37114
37115 if (!args) SWIG_fail;
37116 swig_obj[0] = args;
37117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37118 if (!SWIG_IsOK(res1)) {
37119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37120 }
37121 arg1 = reinterpret_cast< wxWindow * >(argp1);
37122 {
37123 PyThreadState* __tstate = wxPyBeginAllowThreads();
37124 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37125 wxPyEndAllowThreads(__tstate);
37126 if (PyErr_Occurred()) SWIG_fail;
37127 }
37128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37129 return resultobj;
37130 fail:
37131 return NULL;
37132 }
37133
37134
37135 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37136 PyObject *resultobj = 0;
37137 wxWindow *arg1 = (wxWindow *) 0 ;
37138 bool arg2 ;
37139 void *argp1 = 0 ;
37140 int res1 = 0 ;
37141 bool val2 ;
37142 int ecode2 = 0 ;
37143 PyObject * obj0 = 0 ;
37144 PyObject * obj1 = 0 ;
37145 char * kwnames[] = {
37146 (char *) "self",(char *) "autoLayout", NULL
37147 };
37148
37149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37151 if (!SWIG_IsOK(res1)) {
37152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37153 }
37154 arg1 = reinterpret_cast< wxWindow * >(argp1);
37155 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37156 if (!SWIG_IsOK(ecode2)) {
37157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37158 }
37159 arg2 = static_cast< bool >(val2);
37160 {
37161 PyThreadState* __tstate = wxPyBeginAllowThreads();
37162 (arg1)->SetAutoLayout(arg2);
37163 wxPyEndAllowThreads(__tstate);
37164 if (PyErr_Occurred()) SWIG_fail;
37165 }
37166 resultobj = SWIG_Py_Void();
37167 return resultobj;
37168 fail:
37169 return NULL;
37170 }
37171
37172
37173 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37174 PyObject *resultobj = 0;
37175 wxWindow *arg1 = (wxWindow *) 0 ;
37176 bool result;
37177 void *argp1 = 0 ;
37178 int res1 = 0 ;
37179 PyObject *swig_obj[1] ;
37180
37181 if (!args) SWIG_fail;
37182 swig_obj[0] = args;
37183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37184 if (!SWIG_IsOK(res1)) {
37185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37186 }
37187 arg1 = reinterpret_cast< wxWindow * >(argp1);
37188 {
37189 PyThreadState* __tstate = wxPyBeginAllowThreads();
37190 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37191 wxPyEndAllowThreads(__tstate);
37192 if (PyErr_Occurred()) SWIG_fail;
37193 }
37194 {
37195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37196 }
37197 return resultobj;
37198 fail:
37199 return NULL;
37200 }
37201
37202
37203 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37204 PyObject *resultobj = 0;
37205 wxWindow *arg1 = (wxWindow *) 0 ;
37206 bool result;
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_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37216 }
37217 arg1 = reinterpret_cast< wxWindow * >(argp1);
37218 {
37219 PyThreadState* __tstate = wxPyBeginAllowThreads();
37220 result = (bool)(arg1)->Layout();
37221 wxPyEndAllowThreads(__tstate);
37222 if (PyErr_Occurred()) SWIG_fail;
37223 }
37224 {
37225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37226 }
37227 return resultobj;
37228 fail:
37229 return NULL;
37230 }
37231
37232
37233 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37234 PyObject *resultobj = 0;
37235 wxWindow *arg1 = (wxWindow *) 0 ;
37236 wxSizer *arg2 = (wxSizer *) 0 ;
37237 bool arg3 = (bool) true ;
37238 void *argp1 = 0 ;
37239 int res1 = 0 ;
37240 int res2 = 0 ;
37241 bool val3 ;
37242 int ecode3 = 0 ;
37243 PyObject * obj0 = 0 ;
37244 PyObject * obj1 = 0 ;
37245 PyObject * obj2 = 0 ;
37246 char * kwnames[] = {
37247 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37248 };
37249
37250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37252 if (!SWIG_IsOK(res1)) {
37253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37254 }
37255 arg1 = reinterpret_cast< wxWindow * >(argp1);
37256 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37257 if (!SWIG_IsOK(res2)) {
37258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37259 }
37260 if (obj2) {
37261 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37262 if (!SWIG_IsOK(ecode3)) {
37263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37264 }
37265 arg3 = static_cast< bool >(val3);
37266 }
37267 {
37268 PyThreadState* __tstate = wxPyBeginAllowThreads();
37269 (arg1)->SetSizer(arg2,arg3);
37270 wxPyEndAllowThreads(__tstate);
37271 if (PyErr_Occurred()) SWIG_fail;
37272 }
37273 resultobj = SWIG_Py_Void();
37274 return resultobj;
37275 fail:
37276 return NULL;
37277 }
37278
37279
37280 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37281 PyObject *resultobj = 0;
37282 wxWindow *arg1 = (wxWindow *) 0 ;
37283 wxSizer *arg2 = (wxSizer *) 0 ;
37284 bool arg3 = (bool) true ;
37285 void *argp1 = 0 ;
37286 int res1 = 0 ;
37287 int res2 = 0 ;
37288 bool val3 ;
37289 int ecode3 = 0 ;
37290 PyObject * obj0 = 0 ;
37291 PyObject * obj1 = 0 ;
37292 PyObject * obj2 = 0 ;
37293 char * kwnames[] = {
37294 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37295 };
37296
37297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37299 if (!SWIG_IsOK(res1)) {
37300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37301 }
37302 arg1 = reinterpret_cast< wxWindow * >(argp1);
37303 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37304 if (!SWIG_IsOK(res2)) {
37305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37306 }
37307 if (obj2) {
37308 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37309 if (!SWIG_IsOK(ecode3)) {
37310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37311 }
37312 arg3 = static_cast< bool >(val3);
37313 }
37314 {
37315 PyThreadState* __tstate = wxPyBeginAllowThreads();
37316 (arg1)->SetSizerAndFit(arg2,arg3);
37317 wxPyEndAllowThreads(__tstate);
37318 if (PyErr_Occurred()) SWIG_fail;
37319 }
37320 resultobj = SWIG_Py_Void();
37321 return resultobj;
37322 fail:
37323 return NULL;
37324 }
37325
37326
37327 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37328 PyObject *resultobj = 0;
37329 wxWindow *arg1 = (wxWindow *) 0 ;
37330 wxSizer *result = 0 ;
37331 void *argp1 = 0 ;
37332 int res1 = 0 ;
37333 PyObject *swig_obj[1] ;
37334
37335 if (!args) SWIG_fail;
37336 swig_obj[0] = args;
37337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37338 if (!SWIG_IsOK(res1)) {
37339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37340 }
37341 arg1 = reinterpret_cast< wxWindow * >(argp1);
37342 {
37343 PyThreadState* __tstate = wxPyBeginAllowThreads();
37344 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37345 wxPyEndAllowThreads(__tstate);
37346 if (PyErr_Occurred()) SWIG_fail;
37347 }
37348 {
37349 resultobj = wxPyMake_wxObject(result, (bool)0);
37350 }
37351 return resultobj;
37352 fail:
37353 return NULL;
37354 }
37355
37356
37357 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37358 PyObject *resultobj = 0;
37359 wxWindow *arg1 = (wxWindow *) 0 ;
37360 wxSizer *arg2 = (wxSizer *) 0 ;
37361 void *argp1 = 0 ;
37362 int res1 = 0 ;
37363 void *argp2 = 0 ;
37364 int res2 = 0 ;
37365 PyObject * obj0 = 0 ;
37366 PyObject * obj1 = 0 ;
37367 char * kwnames[] = {
37368 (char *) "self",(char *) "sizer", NULL
37369 };
37370
37371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37373 if (!SWIG_IsOK(res1)) {
37374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37375 }
37376 arg1 = reinterpret_cast< wxWindow * >(argp1);
37377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37378 if (!SWIG_IsOK(res2)) {
37379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37380 }
37381 arg2 = reinterpret_cast< wxSizer * >(argp2);
37382 {
37383 PyThreadState* __tstate = wxPyBeginAllowThreads();
37384 (arg1)->SetContainingSizer(arg2);
37385 wxPyEndAllowThreads(__tstate);
37386 if (PyErr_Occurred()) SWIG_fail;
37387 }
37388 resultobj = SWIG_Py_Void();
37389 return resultobj;
37390 fail:
37391 return NULL;
37392 }
37393
37394
37395 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37396 PyObject *resultobj = 0;
37397 wxWindow *arg1 = (wxWindow *) 0 ;
37398 wxSizer *result = 0 ;
37399 void *argp1 = 0 ;
37400 int res1 = 0 ;
37401 PyObject *swig_obj[1] ;
37402
37403 if (!args) SWIG_fail;
37404 swig_obj[0] = args;
37405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37406 if (!SWIG_IsOK(res1)) {
37407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37408 }
37409 arg1 = reinterpret_cast< wxWindow * >(argp1);
37410 {
37411 PyThreadState* __tstate = wxPyBeginAllowThreads();
37412 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37413 wxPyEndAllowThreads(__tstate);
37414 if (PyErr_Occurred()) SWIG_fail;
37415 }
37416 {
37417 resultobj = wxPyMake_wxObject(result, (bool)0);
37418 }
37419 return resultobj;
37420 fail:
37421 return NULL;
37422 }
37423
37424
37425 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37426 PyObject *resultobj = 0;
37427 wxWindow *arg1 = (wxWindow *) 0 ;
37428 void *argp1 = 0 ;
37429 int res1 = 0 ;
37430 PyObject *swig_obj[1] ;
37431
37432 if (!args) SWIG_fail;
37433 swig_obj[0] = args;
37434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37435 if (!SWIG_IsOK(res1)) {
37436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37437 }
37438 arg1 = reinterpret_cast< wxWindow * >(argp1);
37439 {
37440 PyThreadState* __tstate = wxPyBeginAllowThreads();
37441 (arg1)->InheritAttributes();
37442 wxPyEndAllowThreads(__tstate);
37443 if (PyErr_Occurred()) SWIG_fail;
37444 }
37445 resultobj = SWIG_Py_Void();
37446 return resultobj;
37447 fail:
37448 return NULL;
37449 }
37450
37451
37452 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37453 PyObject *resultobj = 0;
37454 wxWindow *arg1 = (wxWindow *) 0 ;
37455 bool result;
37456 void *argp1 = 0 ;
37457 int res1 = 0 ;
37458 PyObject *swig_obj[1] ;
37459
37460 if (!args) SWIG_fail;
37461 swig_obj[0] = args;
37462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37463 if (!SWIG_IsOK(res1)) {
37464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37465 }
37466 arg1 = reinterpret_cast< wxWindow * >(argp1);
37467 {
37468 PyThreadState* __tstate = wxPyBeginAllowThreads();
37469 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37470 wxPyEndAllowThreads(__tstate);
37471 if (PyErr_Occurred()) SWIG_fail;
37472 }
37473 {
37474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37475 }
37476 return resultobj;
37477 fail:
37478 return NULL;
37479 }
37480
37481
37482 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37483 PyObject *obj;
37484 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37485 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37486 return SWIG_Py_Void();
37487 }
37488
37489 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37490 return SWIG_Python_InitShadowInstance(args);
37491 }
37492
37493 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37494 PyObject *resultobj = 0;
37495 long arg1 ;
37496 wxWindow *arg2 = (wxWindow *) NULL ;
37497 wxWindow *result = 0 ;
37498 long val1 ;
37499 int ecode1 = 0 ;
37500 void *argp2 = 0 ;
37501 int res2 = 0 ;
37502 PyObject * obj0 = 0 ;
37503 PyObject * obj1 = 0 ;
37504 char * kwnames[] = {
37505 (char *) "id",(char *) "parent", NULL
37506 };
37507
37508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37509 ecode1 = SWIG_AsVal_long(obj0, &val1);
37510 if (!SWIG_IsOK(ecode1)) {
37511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37512 }
37513 arg1 = static_cast< long >(val1);
37514 if (obj1) {
37515 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37516 if (!SWIG_IsOK(res2)) {
37517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37518 }
37519 arg2 = reinterpret_cast< wxWindow * >(argp2);
37520 }
37521 {
37522 if (!wxPyCheckForApp()) SWIG_fail;
37523 PyThreadState* __tstate = wxPyBeginAllowThreads();
37524 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37525 wxPyEndAllowThreads(__tstate);
37526 if (PyErr_Occurred()) SWIG_fail;
37527 }
37528 {
37529 resultobj = wxPyMake_wxObject(result, 0);
37530 }
37531 return resultobj;
37532 fail:
37533 return NULL;
37534 }
37535
37536
37537 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37538 PyObject *resultobj = 0;
37539 wxString *arg1 = 0 ;
37540 wxWindow *arg2 = (wxWindow *) NULL ;
37541 wxWindow *result = 0 ;
37542 bool temp1 = false ;
37543 void *argp2 = 0 ;
37544 int res2 = 0 ;
37545 PyObject * obj0 = 0 ;
37546 PyObject * obj1 = 0 ;
37547 char * kwnames[] = {
37548 (char *) "name",(char *) "parent", NULL
37549 };
37550
37551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37552 {
37553 arg1 = wxString_in_helper(obj0);
37554 if (arg1 == NULL) SWIG_fail;
37555 temp1 = true;
37556 }
37557 if (obj1) {
37558 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37559 if (!SWIG_IsOK(res2)) {
37560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37561 }
37562 arg2 = reinterpret_cast< wxWindow * >(argp2);
37563 }
37564 {
37565 if (!wxPyCheckForApp()) SWIG_fail;
37566 PyThreadState* __tstate = wxPyBeginAllowThreads();
37567 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37568 wxPyEndAllowThreads(__tstate);
37569 if (PyErr_Occurred()) SWIG_fail;
37570 }
37571 {
37572 resultobj = wxPyMake_wxObject(result, 0);
37573 }
37574 {
37575 if (temp1)
37576 delete arg1;
37577 }
37578 return resultobj;
37579 fail:
37580 {
37581 if (temp1)
37582 delete arg1;
37583 }
37584 return NULL;
37585 }
37586
37587
37588 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37589 PyObject *resultobj = 0;
37590 wxString *arg1 = 0 ;
37591 wxWindow *arg2 = (wxWindow *) NULL ;
37592 wxWindow *result = 0 ;
37593 bool temp1 = false ;
37594 void *argp2 = 0 ;
37595 int res2 = 0 ;
37596 PyObject * obj0 = 0 ;
37597 PyObject * obj1 = 0 ;
37598 char * kwnames[] = {
37599 (char *) "label",(char *) "parent", NULL
37600 };
37601
37602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37603 {
37604 arg1 = wxString_in_helper(obj0);
37605 if (arg1 == NULL) SWIG_fail;
37606 temp1 = true;
37607 }
37608 if (obj1) {
37609 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37610 if (!SWIG_IsOK(res2)) {
37611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37612 }
37613 arg2 = reinterpret_cast< wxWindow * >(argp2);
37614 }
37615 {
37616 if (!wxPyCheckForApp()) SWIG_fail;
37617 PyThreadState* __tstate = wxPyBeginAllowThreads();
37618 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37619 wxPyEndAllowThreads(__tstate);
37620 if (PyErr_Occurred()) SWIG_fail;
37621 }
37622 {
37623 resultobj = wxPyMake_wxObject(result, 0);
37624 }
37625 {
37626 if (temp1)
37627 delete arg1;
37628 }
37629 return resultobj;
37630 fail:
37631 {
37632 if (temp1)
37633 delete arg1;
37634 }
37635 return NULL;
37636 }
37637
37638
37639 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37640 PyObject *resultobj = 0;
37641 wxWindow *arg1 = (wxWindow *) 0 ;
37642 unsigned long arg2 ;
37643 wxWindow *result = 0 ;
37644 void *argp1 = 0 ;
37645 int res1 = 0 ;
37646 unsigned long val2 ;
37647 int ecode2 = 0 ;
37648 PyObject * obj0 = 0 ;
37649 PyObject * obj1 = 0 ;
37650 char * kwnames[] = {
37651 (char *) "parent",(char *) "_hWnd", NULL
37652 };
37653
37654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37656 if (!SWIG_IsOK(res1)) {
37657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37658 }
37659 arg1 = reinterpret_cast< wxWindow * >(argp1);
37660 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37661 if (!SWIG_IsOK(ecode2)) {
37662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37663 }
37664 arg2 = static_cast< unsigned long >(val2);
37665 {
37666 PyThreadState* __tstate = wxPyBeginAllowThreads();
37667 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37668 wxPyEndAllowThreads(__tstate);
37669 if (PyErr_Occurred()) SWIG_fail;
37670 }
37671 {
37672 resultobj = wxPyMake_wxObject(result, 0);
37673 }
37674 return resultobj;
37675 fail:
37676 return NULL;
37677 }
37678
37679
37680 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37681 PyObject *resultobj = 0;
37682 PyObject *result = 0 ;
37683
37684 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37685 {
37686 PyThreadState* __tstate = wxPyBeginAllowThreads();
37687 result = (PyObject *)GetTopLevelWindows();
37688 wxPyEndAllowThreads(__tstate);
37689 if (PyErr_Occurred()) SWIG_fail;
37690 }
37691 resultobj = result;
37692 return resultobj;
37693 fail:
37694 return NULL;
37695 }
37696
37697
37698 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37699 PyObject *resultobj = 0;
37700 wxValidator *result = 0 ;
37701
37702 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37703 {
37704 PyThreadState* __tstate = wxPyBeginAllowThreads();
37705 result = (wxValidator *)new wxValidator();
37706 wxPyEndAllowThreads(__tstate);
37707 if (PyErr_Occurred()) SWIG_fail;
37708 }
37709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37710 return resultobj;
37711 fail:
37712 return NULL;
37713 }
37714
37715
37716 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37717 PyObject *resultobj = 0;
37718 wxValidator *arg1 = (wxValidator *) 0 ;
37719 wxValidator *result = 0 ;
37720 void *argp1 = 0 ;
37721 int res1 = 0 ;
37722 PyObject *swig_obj[1] ;
37723
37724 if (!args) SWIG_fail;
37725 swig_obj[0] = args;
37726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37727 if (!SWIG_IsOK(res1)) {
37728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37729 }
37730 arg1 = reinterpret_cast< wxValidator * >(argp1);
37731 {
37732 PyThreadState* __tstate = wxPyBeginAllowThreads();
37733 result = (wxValidator *)(arg1)->Clone();
37734 wxPyEndAllowThreads(__tstate);
37735 if (PyErr_Occurred()) SWIG_fail;
37736 }
37737 {
37738 resultobj = wxPyMake_wxObject(result, 0);
37739 }
37740 return resultobj;
37741 fail:
37742 return NULL;
37743 }
37744
37745
37746 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37747 PyObject *resultobj = 0;
37748 wxValidator *arg1 = (wxValidator *) 0 ;
37749 wxWindow *arg2 = (wxWindow *) 0 ;
37750 bool result;
37751 void *argp1 = 0 ;
37752 int res1 = 0 ;
37753 void *argp2 = 0 ;
37754 int res2 = 0 ;
37755 PyObject * obj0 = 0 ;
37756 PyObject * obj1 = 0 ;
37757 char * kwnames[] = {
37758 (char *) "self",(char *) "parent", NULL
37759 };
37760
37761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37763 if (!SWIG_IsOK(res1)) {
37764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37765 }
37766 arg1 = reinterpret_cast< wxValidator * >(argp1);
37767 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37768 if (!SWIG_IsOK(res2)) {
37769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37770 }
37771 arg2 = reinterpret_cast< wxWindow * >(argp2);
37772 {
37773 PyThreadState* __tstate = wxPyBeginAllowThreads();
37774 result = (bool)(arg1)->Validate(arg2);
37775 wxPyEndAllowThreads(__tstate);
37776 if (PyErr_Occurred()) SWIG_fail;
37777 }
37778 {
37779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37780 }
37781 return resultobj;
37782 fail:
37783 return NULL;
37784 }
37785
37786
37787 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37788 PyObject *resultobj = 0;
37789 wxValidator *arg1 = (wxValidator *) 0 ;
37790 bool result;
37791 void *argp1 = 0 ;
37792 int res1 = 0 ;
37793 PyObject *swig_obj[1] ;
37794
37795 if (!args) SWIG_fail;
37796 swig_obj[0] = args;
37797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37798 if (!SWIG_IsOK(res1)) {
37799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37800 }
37801 arg1 = reinterpret_cast< wxValidator * >(argp1);
37802 {
37803 PyThreadState* __tstate = wxPyBeginAllowThreads();
37804 result = (bool)(arg1)->TransferToWindow();
37805 wxPyEndAllowThreads(__tstate);
37806 if (PyErr_Occurred()) SWIG_fail;
37807 }
37808 {
37809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37810 }
37811 return resultobj;
37812 fail:
37813 return NULL;
37814 }
37815
37816
37817 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37818 PyObject *resultobj = 0;
37819 wxValidator *arg1 = (wxValidator *) 0 ;
37820 bool result;
37821 void *argp1 = 0 ;
37822 int res1 = 0 ;
37823 PyObject *swig_obj[1] ;
37824
37825 if (!args) SWIG_fail;
37826 swig_obj[0] = args;
37827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37828 if (!SWIG_IsOK(res1)) {
37829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37830 }
37831 arg1 = reinterpret_cast< wxValidator * >(argp1);
37832 {
37833 PyThreadState* __tstate = wxPyBeginAllowThreads();
37834 result = (bool)(arg1)->TransferFromWindow();
37835 wxPyEndAllowThreads(__tstate);
37836 if (PyErr_Occurred()) SWIG_fail;
37837 }
37838 {
37839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37840 }
37841 return resultobj;
37842 fail:
37843 return NULL;
37844 }
37845
37846
37847 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37848 PyObject *resultobj = 0;
37849 wxValidator *arg1 = (wxValidator *) 0 ;
37850 wxWindow *result = 0 ;
37851 void *argp1 = 0 ;
37852 int res1 = 0 ;
37853 PyObject *swig_obj[1] ;
37854
37855 if (!args) SWIG_fail;
37856 swig_obj[0] = args;
37857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37858 if (!SWIG_IsOK(res1)) {
37859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37860 }
37861 arg1 = reinterpret_cast< wxValidator * >(argp1);
37862 {
37863 PyThreadState* __tstate = wxPyBeginAllowThreads();
37864 result = (wxWindow *)(arg1)->GetWindow();
37865 wxPyEndAllowThreads(__tstate);
37866 if (PyErr_Occurred()) SWIG_fail;
37867 }
37868 {
37869 resultobj = wxPyMake_wxObject(result, 0);
37870 }
37871 return resultobj;
37872 fail:
37873 return NULL;
37874 }
37875
37876
37877 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37878 PyObject *resultobj = 0;
37879 wxValidator *arg1 = (wxValidator *) 0 ;
37880 wxWindow *arg2 = (wxWindow *) 0 ;
37881 void *argp1 = 0 ;
37882 int res1 = 0 ;
37883 void *argp2 = 0 ;
37884 int res2 = 0 ;
37885 PyObject * obj0 = 0 ;
37886 PyObject * obj1 = 0 ;
37887 char * kwnames[] = {
37888 (char *) "self",(char *) "window", NULL
37889 };
37890
37891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37893 if (!SWIG_IsOK(res1)) {
37894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37895 }
37896 arg1 = reinterpret_cast< wxValidator * >(argp1);
37897 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37898 if (!SWIG_IsOK(res2)) {
37899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37900 }
37901 arg2 = reinterpret_cast< wxWindow * >(argp2);
37902 {
37903 PyThreadState* __tstate = wxPyBeginAllowThreads();
37904 (arg1)->SetWindow(arg2);
37905 wxPyEndAllowThreads(__tstate);
37906 if (PyErr_Occurred()) SWIG_fail;
37907 }
37908 resultobj = SWIG_Py_Void();
37909 return resultobj;
37910 fail:
37911 return NULL;
37912 }
37913
37914
37915 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37916 PyObject *resultobj = 0;
37917 bool result;
37918
37919 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37920 {
37921 PyThreadState* __tstate = wxPyBeginAllowThreads();
37922 result = (bool)wxValidator::IsSilent();
37923 wxPyEndAllowThreads(__tstate);
37924 if (PyErr_Occurred()) SWIG_fail;
37925 }
37926 {
37927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37928 }
37929 return resultobj;
37930 fail:
37931 return NULL;
37932 }
37933
37934
37935 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37936 PyObject *resultobj = 0;
37937 int arg1 = (int) true ;
37938 int val1 ;
37939 int ecode1 = 0 ;
37940 PyObject * obj0 = 0 ;
37941 char * kwnames[] = {
37942 (char *) "doIt", NULL
37943 };
37944
37945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37946 if (obj0) {
37947 ecode1 = SWIG_AsVal_int(obj0, &val1);
37948 if (!SWIG_IsOK(ecode1)) {
37949 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37950 }
37951 arg1 = static_cast< int >(val1);
37952 }
37953 {
37954 PyThreadState* __tstate = wxPyBeginAllowThreads();
37955 wxValidator::SetBellOnError(arg1);
37956 wxPyEndAllowThreads(__tstate);
37957 if (PyErr_Occurred()) SWIG_fail;
37958 }
37959 resultobj = SWIG_Py_Void();
37960 return resultobj;
37961 fail:
37962 return NULL;
37963 }
37964
37965
37966 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37967 PyObject *obj;
37968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37969 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37970 return SWIG_Py_Void();
37971 }
37972
37973 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37974 return SWIG_Python_InitShadowInstance(args);
37975 }
37976
37977 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37978 PyObject *resultobj = 0;
37979 wxPyValidator *result = 0 ;
37980
37981 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37982 {
37983 PyThreadState* __tstate = wxPyBeginAllowThreads();
37984 result = (wxPyValidator *)new wxPyValidator();
37985 wxPyEndAllowThreads(__tstate);
37986 if (PyErr_Occurred()) SWIG_fail;
37987 }
37988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37989 return resultobj;
37990 fail:
37991 return NULL;
37992 }
37993
37994
37995 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37996 PyObject *resultobj = 0;
37997 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37998 PyObject *arg2 = (PyObject *) 0 ;
37999 PyObject *arg3 = (PyObject *) 0 ;
38000 int arg4 = (int) true ;
38001 void *argp1 = 0 ;
38002 int res1 = 0 ;
38003 int val4 ;
38004 int ecode4 = 0 ;
38005 PyObject * obj0 = 0 ;
38006 PyObject * obj1 = 0 ;
38007 PyObject * obj2 = 0 ;
38008 PyObject * obj3 = 0 ;
38009 char * kwnames[] = {
38010 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38011 };
38012
38013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38015 if (!SWIG_IsOK(res1)) {
38016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38017 }
38018 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38019 arg2 = obj1;
38020 arg3 = obj2;
38021 if (obj3) {
38022 ecode4 = SWIG_AsVal_int(obj3, &val4);
38023 if (!SWIG_IsOK(ecode4)) {
38024 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38025 }
38026 arg4 = static_cast< int >(val4);
38027 }
38028 {
38029 PyThreadState* __tstate = wxPyBeginAllowThreads();
38030 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38031 wxPyEndAllowThreads(__tstate);
38032 if (PyErr_Occurred()) SWIG_fail;
38033 }
38034 resultobj = SWIG_Py_Void();
38035 return resultobj;
38036 fail:
38037 return NULL;
38038 }
38039
38040
38041 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38042 PyObject *obj;
38043 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38044 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38045 return SWIG_Py_Void();
38046 }
38047
38048 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38049 return SWIG_Python_InitShadowInstance(args);
38050 }
38051
38052 SWIGINTERN int DefaultValidator_set(PyObject *) {
38053 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38054 return 1;
38055 }
38056
38057
38058 SWIGINTERN PyObject *DefaultValidator_get(void) {
38059 PyObject *pyobj = 0;
38060
38061 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38062 return pyobj;
38063 }
38064
38065
38066 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38067 PyObject *resultobj = 0;
38068 wxString const &arg1_defvalue = wxPyEmptyString ;
38069 wxString *arg1 = (wxString *) &arg1_defvalue ;
38070 long arg2 = (long) 0 ;
38071 wxMenu *result = 0 ;
38072 bool temp1 = false ;
38073 long val2 ;
38074 int ecode2 = 0 ;
38075 PyObject * obj0 = 0 ;
38076 PyObject * obj1 = 0 ;
38077 char * kwnames[] = {
38078 (char *) "title",(char *) "style", NULL
38079 };
38080
38081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38082 if (obj0) {
38083 {
38084 arg1 = wxString_in_helper(obj0);
38085 if (arg1 == NULL) SWIG_fail;
38086 temp1 = true;
38087 }
38088 }
38089 if (obj1) {
38090 ecode2 = SWIG_AsVal_long(obj1, &val2);
38091 if (!SWIG_IsOK(ecode2)) {
38092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38093 }
38094 arg2 = static_cast< long >(val2);
38095 }
38096 {
38097 if (!wxPyCheckForApp()) SWIG_fail;
38098 PyThreadState* __tstate = wxPyBeginAllowThreads();
38099 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38100 wxPyEndAllowThreads(__tstate);
38101 if (PyErr_Occurred()) SWIG_fail;
38102 }
38103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38104 {
38105 if (temp1)
38106 delete arg1;
38107 }
38108 return resultobj;
38109 fail:
38110 {
38111 if (temp1)
38112 delete arg1;
38113 }
38114 return NULL;
38115 }
38116
38117
38118 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38119 PyObject *resultobj = 0;
38120 wxMenu *arg1 = (wxMenu *) 0 ;
38121 int arg2 ;
38122 wxString *arg3 = 0 ;
38123 wxString const &arg4_defvalue = wxPyEmptyString ;
38124 wxString *arg4 = (wxString *) &arg4_defvalue ;
38125 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38126 wxMenuItem *result = 0 ;
38127 void *argp1 = 0 ;
38128 int res1 = 0 ;
38129 int val2 ;
38130 int ecode2 = 0 ;
38131 bool temp3 = false ;
38132 bool temp4 = false ;
38133 int val5 ;
38134 int ecode5 = 0 ;
38135 PyObject * obj0 = 0 ;
38136 PyObject * obj1 = 0 ;
38137 PyObject * obj2 = 0 ;
38138 PyObject * obj3 = 0 ;
38139 PyObject * obj4 = 0 ;
38140 char * kwnames[] = {
38141 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38142 };
38143
38144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38146 if (!SWIG_IsOK(res1)) {
38147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38148 }
38149 arg1 = reinterpret_cast< wxMenu * >(argp1);
38150 ecode2 = SWIG_AsVal_int(obj1, &val2);
38151 if (!SWIG_IsOK(ecode2)) {
38152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38153 }
38154 arg2 = static_cast< int >(val2);
38155 {
38156 arg3 = wxString_in_helper(obj2);
38157 if (arg3 == NULL) SWIG_fail;
38158 temp3 = true;
38159 }
38160 if (obj3) {
38161 {
38162 arg4 = wxString_in_helper(obj3);
38163 if (arg4 == NULL) SWIG_fail;
38164 temp4 = true;
38165 }
38166 }
38167 if (obj4) {
38168 ecode5 = SWIG_AsVal_int(obj4, &val5);
38169 if (!SWIG_IsOK(ecode5)) {
38170 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38171 }
38172 arg5 = static_cast< wxItemKind >(val5);
38173 }
38174 {
38175 PyThreadState* __tstate = wxPyBeginAllowThreads();
38176 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38177 wxPyEndAllowThreads(__tstate);
38178 if (PyErr_Occurred()) SWIG_fail;
38179 }
38180 {
38181 resultobj = wxPyMake_wxObject(result, (bool)0);
38182 }
38183 {
38184 if (temp3)
38185 delete arg3;
38186 }
38187 {
38188 if (temp4)
38189 delete arg4;
38190 }
38191 return resultobj;
38192 fail:
38193 {
38194 if (temp3)
38195 delete arg3;
38196 }
38197 {
38198 if (temp4)
38199 delete arg4;
38200 }
38201 return NULL;
38202 }
38203
38204
38205 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38206 PyObject *resultobj = 0;
38207 wxMenu *arg1 = (wxMenu *) 0 ;
38208 wxMenuItem *result = 0 ;
38209 void *argp1 = 0 ;
38210 int res1 = 0 ;
38211 PyObject *swig_obj[1] ;
38212
38213 if (!args) SWIG_fail;
38214 swig_obj[0] = args;
38215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38216 if (!SWIG_IsOK(res1)) {
38217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38218 }
38219 arg1 = reinterpret_cast< wxMenu * >(argp1);
38220 {
38221 PyThreadState* __tstate = wxPyBeginAllowThreads();
38222 result = (wxMenuItem *)(arg1)->AppendSeparator();
38223 wxPyEndAllowThreads(__tstate);
38224 if (PyErr_Occurred()) SWIG_fail;
38225 }
38226 {
38227 resultobj = wxPyMake_wxObject(result, (bool)0);
38228 }
38229 return resultobj;
38230 fail:
38231 return NULL;
38232 }
38233
38234
38235 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38236 PyObject *resultobj = 0;
38237 wxMenu *arg1 = (wxMenu *) 0 ;
38238 int arg2 ;
38239 wxString *arg3 = 0 ;
38240 wxString const &arg4_defvalue = wxPyEmptyString ;
38241 wxString *arg4 = (wxString *) &arg4_defvalue ;
38242 wxMenuItem *result = 0 ;
38243 void *argp1 = 0 ;
38244 int res1 = 0 ;
38245 int val2 ;
38246 int ecode2 = 0 ;
38247 bool temp3 = false ;
38248 bool temp4 = false ;
38249 PyObject * obj0 = 0 ;
38250 PyObject * obj1 = 0 ;
38251 PyObject * obj2 = 0 ;
38252 PyObject * obj3 = 0 ;
38253 char * kwnames[] = {
38254 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38255 };
38256
38257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38259 if (!SWIG_IsOK(res1)) {
38260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38261 }
38262 arg1 = reinterpret_cast< wxMenu * >(argp1);
38263 ecode2 = SWIG_AsVal_int(obj1, &val2);
38264 if (!SWIG_IsOK(ecode2)) {
38265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38266 }
38267 arg2 = static_cast< int >(val2);
38268 {
38269 arg3 = wxString_in_helper(obj2);
38270 if (arg3 == NULL) SWIG_fail;
38271 temp3 = true;
38272 }
38273 if (obj3) {
38274 {
38275 arg4 = wxString_in_helper(obj3);
38276 if (arg4 == NULL) SWIG_fail;
38277 temp4 = true;
38278 }
38279 }
38280 {
38281 PyThreadState* __tstate = wxPyBeginAllowThreads();
38282 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38283 wxPyEndAllowThreads(__tstate);
38284 if (PyErr_Occurred()) SWIG_fail;
38285 }
38286 {
38287 resultobj = wxPyMake_wxObject(result, (bool)0);
38288 }
38289 {
38290 if (temp3)
38291 delete arg3;
38292 }
38293 {
38294 if (temp4)
38295 delete arg4;
38296 }
38297 return resultobj;
38298 fail:
38299 {
38300 if (temp3)
38301 delete arg3;
38302 }
38303 {
38304 if (temp4)
38305 delete arg4;
38306 }
38307 return NULL;
38308 }
38309
38310
38311 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38312 PyObject *resultobj = 0;
38313 wxMenu *arg1 = (wxMenu *) 0 ;
38314 int arg2 ;
38315 wxString *arg3 = 0 ;
38316 wxString const &arg4_defvalue = wxPyEmptyString ;
38317 wxString *arg4 = (wxString *) &arg4_defvalue ;
38318 wxMenuItem *result = 0 ;
38319 void *argp1 = 0 ;
38320 int res1 = 0 ;
38321 int val2 ;
38322 int ecode2 = 0 ;
38323 bool temp3 = false ;
38324 bool temp4 = false ;
38325 PyObject * obj0 = 0 ;
38326 PyObject * obj1 = 0 ;
38327 PyObject * obj2 = 0 ;
38328 PyObject * obj3 = 0 ;
38329 char * kwnames[] = {
38330 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38331 };
38332
38333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38335 if (!SWIG_IsOK(res1)) {
38336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38337 }
38338 arg1 = reinterpret_cast< wxMenu * >(argp1);
38339 ecode2 = SWIG_AsVal_int(obj1, &val2);
38340 if (!SWIG_IsOK(ecode2)) {
38341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38342 }
38343 arg2 = static_cast< int >(val2);
38344 {
38345 arg3 = wxString_in_helper(obj2);
38346 if (arg3 == NULL) SWIG_fail;
38347 temp3 = true;
38348 }
38349 if (obj3) {
38350 {
38351 arg4 = wxString_in_helper(obj3);
38352 if (arg4 == NULL) SWIG_fail;
38353 temp4 = true;
38354 }
38355 }
38356 {
38357 PyThreadState* __tstate = wxPyBeginAllowThreads();
38358 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38359 wxPyEndAllowThreads(__tstate);
38360 if (PyErr_Occurred()) SWIG_fail;
38361 }
38362 {
38363 resultobj = wxPyMake_wxObject(result, (bool)0);
38364 }
38365 {
38366 if (temp3)
38367 delete arg3;
38368 }
38369 {
38370 if (temp4)
38371 delete arg4;
38372 }
38373 return resultobj;
38374 fail:
38375 {
38376 if (temp3)
38377 delete arg3;
38378 }
38379 {
38380 if (temp4)
38381 delete arg4;
38382 }
38383 return NULL;
38384 }
38385
38386
38387 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38388 PyObject *resultobj = 0;
38389 wxMenu *arg1 = (wxMenu *) 0 ;
38390 int arg2 ;
38391 wxString *arg3 = 0 ;
38392 wxMenu *arg4 = (wxMenu *) 0 ;
38393 wxString const &arg5_defvalue = wxPyEmptyString ;
38394 wxString *arg5 = (wxString *) &arg5_defvalue ;
38395 wxMenuItem *result = 0 ;
38396 void *argp1 = 0 ;
38397 int res1 = 0 ;
38398 int val2 ;
38399 int ecode2 = 0 ;
38400 bool temp3 = false ;
38401 void *argp4 = 0 ;
38402 int res4 = 0 ;
38403 bool temp5 = false ;
38404 PyObject * obj0 = 0 ;
38405 PyObject * obj1 = 0 ;
38406 PyObject * obj2 = 0 ;
38407 PyObject * obj3 = 0 ;
38408 PyObject * obj4 = 0 ;
38409 char * kwnames[] = {
38410 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38411 };
38412
38413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38415 if (!SWIG_IsOK(res1)) {
38416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38417 }
38418 arg1 = reinterpret_cast< wxMenu * >(argp1);
38419 ecode2 = SWIG_AsVal_int(obj1, &val2);
38420 if (!SWIG_IsOK(ecode2)) {
38421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38422 }
38423 arg2 = static_cast< int >(val2);
38424 {
38425 arg3 = wxString_in_helper(obj2);
38426 if (arg3 == NULL) SWIG_fail;
38427 temp3 = true;
38428 }
38429 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38430 if (!SWIG_IsOK(res4)) {
38431 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38432 }
38433 arg4 = reinterpret_cast< wxMenu * >(argp4);
38434 if (obj4) {
38435 {
38436 arg5 = wxString_in_helper(obj4);
38437 if (arg5 == NULL) SWIG_fail;
38438 temp5 = true;
38439 }
38440 }
38441 {
38442 PyThreadState* __tstate = wxPyBeginAllowThreads();
38443 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38444 wxPyEndAllowThreads(__tstate);
38445 if (PyErr_Occurred()) SWIG_fail;
38446 }
38447 {
38448 resultobj = wxPyMake_wxObject(result, (bool)0);
38449 }
38450 {
38451 if (temp3)
38452 delete arg3;
38453 }
38454 {
38455 if (temp5)
38456 delete arg5;
38457 }
38458 return resultobj;
38459 fail:
38460 {
38461 if (temp3)
38462 delete arg3;
38463 }
38464 {
38465 if (temp5)
38466 delete arg5;
38467 }
38468 return NULL;
38469 }
38470
38471
38472 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38473 PyObject *resultobj = 0;
38474 wxMenu *arg1 = (wxMenu *) 0 ;
38475 wxMenu *arg2 = (wxMenu *) 0 ;
38476 wxString *arg3 = 0 ;
38477 wxString const &arg4_defvalue = wxPyEmptyString ;
38478 wxString *arg4 = (wxString *) &arg4_defvalue ;
38479 wxMenuItem *result = 0 ;
38480 void *argp1 = 0 ;
38481 int res1 = 0 ;
38482 void *argp2 = 0 ;
38483 int res2 = 0 ;
38484 bool temp3 = false ;
38485 bool temp4 = false ;
38486 PyObject * obj0 = 0 ;
38487 PyObject * obj1 = 0 ;
38488 PyObject * obj2 = 0 ;
38489 PyObject * obj3 = 0 ;
38490 char * kwnames[] = {
38491 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38492 };
38493
38494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38496 if (!SWIG_IsOK(res1)) {
38497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38498 }
38499 arg1 = reinterpret_cast< wxMenu * >(argp1);
38500 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38501 if (!SWIG_IsOK(res2)) {
38502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38503 }
38504 arg2 = reinterpret_cast< wxMenu * >(argp2);
38505 {
38506 arg3 = wxString_in_helper(obj2);
38507 if (arg3 == NULL) SWIG_fail;
38508 temp3 = true;
38509 }
38510 if (obj3) {
38511 {
38512 arg4 = wxString_in_helper(obj3);
38513 if (arg4 == NULL) SWIG_fail;
38514 temp4 = true;
38515 }
38516 }
38517 {
38518 PyThreadState* __tstate = wxPyBeginAllowThreads();
38519 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38520 wxPyEndAllowThreads(__tstate);
38521 if (PyErr_Occurred()) SWIG_fail;
38522 }
38523 {
38524 resultobj = wxPyMake_wxObject(result, (bool)0);
38525 }
38526 {
38527 if (temp3)
38528 delete arg3;
38529 }
38530 {
38531 if (temp4)
38532 delete arg4;
38533 }
38534 return resultobj;
38535 fail:
38536 {
38537 if (temp3)
38538 delete arg3;
38539 }
38540 {
38541 if (temp4)
38542 delete arg4;
38543 }
38544 return NULL;
38545 }
38546
38547
38548 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38549 PyObject *resultobj = 0;
38550 wxMenu *arg1 = (wxMenu *) 0 ;
38551 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38552 wxMenuItem *result = 0 ;
38553 void *argp1 = 0 ;
38554 int res1 = 0 ;
38555 int res2 = 0 ;
38556 PyObject * obj0 = 0 ;
38557 PyObject * obj1 = 0 ;
38558 char * kwnames[] = {
38559 (char *) "self",(char *) "item", NULL
38560 };
38561
38562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38564 if (!SWIG_IsOK(res1)) {
38565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38566 }
38567 arg1 = reinterpret_cast< wxMenu * >(argp1);
38568 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38569 if (!SWIG_IsOK(res2)) {
38570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38571 }
38572 {
38573 PyThreadState* __tstate = wxPyBeginAllowThreads();
38574 result = (wxMenuItem *)(arg1)->Append(arg2);
38575 wxPyEndAllowThreads(__tstate);
38576 if (PyErr_Occurred()) SWIG_fail;
38577 }
38578 {
38579 resultobj = wxPyMake_wxObject(result, (bool)0);
38580 }
38581 return resultobj;
38582 fail:
38583 return NULL;
38584 }
38585
38586
38587 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38588 PyObject *resultobj = 0;
38589 wxMenu *arg1 = (wxMenu *) 0 ;
38590 size_t arg2 ;
38591 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38592 wxMenuItem *result = 0 ;
38593 void *argp1 = 0 ;
38594 int res1 = 0 ;
38595 size_t val2 ;
38596 int ecode2 = 0 ;
38597 int res3 = 0 ;
38598 PyObject * obj0 = 0 ;
38599 PyObject * obj1 = 0 ;
38600 PyObject * obj2 = 0 ;
38601 char * kwnames[] = {
38602 (char *) "self",(char *) "pos",(char *) "item", NULL
38603 };
38604
38605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38607 if (!SWIG_IsOK(res1)) {
38608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38609 }
38610 arg1 = reinterpret_cast< wxMenu * >(argp1);
38611 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38612 if (!SWIG_IsOK(ecode2)) {
38613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38614 }
38615 arg2 = static_cast< size_t >(val2);
38616 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38617 if (!SWIG_IsOK(res3)) {
38618 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38619 }
38620 {
38621 PyThreadState* __tstate = wxPyBeginAllowThreads();
38622 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38623 wxPyEndAllowThreads(__tstate);
38624 if (PyErr_Occurred()) SWIG_fail;
38625 }
38626 {
38627 resultobj = wxPyMake_wxObject(result, (bool)0);
38628 }
38629 return resultobj;
38630 fail:
38631 return NULL;
38632 }
38633
38634
38635 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38636 PyObject *resultobj = 0;
38637 wxMenu *arg1 = (wxMenu *) 0 ;
38638 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38639 wxMenuItem *result = 0 ;
38640 void *argp1 = 0 ;
38641 int res1 = 0 ;
38642 int res2 = 0 ;
38643 PyObject * obj0 = 0 ;
38644 PyObject * obj1 = 0 ;
38645 char * kwnames[] = {
38646 (char *) "self",(char *) "item", NULL
38647 };
38648
38649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38651 if (!SWIG_IsOK(res1)) {
38652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38653 }
38654 arg1 = reinterpret_cast< wxMenu * >(argp1);
38655 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38656 if (!SWIG_IsOK(res2)) {
38657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38658 }
38659 {
38660 PyThreadState* __tstate = wxPyBeginAllowThreads();
38661 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38662 wxPyEndAllowThreads(__tstate);
38663 if (PyErr_Occurred()) SWIG_fail;
38664 }
38665 {
38666 resultobj = wxPyMake_wxObject(result, (bool)0);
38667 }
38668 return resultobj;
38669 fail:
38670 return NULL;
38671 }
38672
38673
38674 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38675 PyObject *resultobj = 0;
38676 wxMenu *arg1 = (wxMenu *) 0 ;
38677 void *argp1 = 0 ;
38678 int res1 = 0 ;
38679 PyObject *swig_obj[1] ;
38680
38681 if (!args) SWIG_fail;
38682 swig_obj[0] = args;
38683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38684 if (!SWIG_IsOK(res1)) {
38685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38686 }
38687 arg1 = reinterpret_cast< wxMenu * >(argp1);
38688 {
38689 PyThreadState* __tstate = wxPyBeginAllowThreads();
38690 (arg1)->Break();
38691 wxPyEndAllowThreads(__tstate);
38692 if (PyErr_Occurred()) SWIG_fail;
38693 }
38694 resultobj = SWIG_Py_Void();
38695 return resultobj;
38696 fail:
38697 return NULL;
38698 }
38699
38700
38701 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38702 PyObject *resultobj = 0;
38703 wxMenu *arg1 = (wxMenu *) 0 ;
38704 size_t arg2 ;
38705 int arg3 ;
38706 wxString *arg4 = 0 ;
38707 wxString const &arg5_defvalue = wxPyEmptyString ;
38708 wxString *arg5 = (wxString *) &arg5_defvalue ;
38709 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38710 wxMenuItem *result = 0 ;
38711 void *argp1 = 0 ;
38712 int res1 = 0 ;
38713 size_t val2 ;
38714 int ecode2 = 0 ;
38715 int val3 ;
38716 int ecode3 = 0 ;
38717 bool temp4 = false ;
38718 bool temp5 = false ;
38719 int val6 ;
38720 int ecode6 = 0 ;
38721 PyObject * obj0 = 0 ;
38722 PyObject * obj1 = 0 ;
38723 PyObject * obj2 = 0 ;
38724 PyObject * obj3 = 0 ;
38725 PyObject * obj4 = 0 ;
38726 PyObject * obj5 = 0 ;
38727 char * kwnames[] = {
38728 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38729 };
38730
38731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38733 if (!SWIG_IsOK(res1)) {
38734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38735 }
38736 arg1 = reinterpret_cast< wxMenu * >(argp1);
38737 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38738 if (!SWIG_IsOK(ecode2)) {
38739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38740 }
38741 arg2 = static_cast< size_t >(val2);
38742 ecode3 = SWIG_AsVal_int(obj2, &val3);
38743 if (!SWIG_IsOK(ecode3)) {
38744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38745 }
38746 arg3 = static_cast< int >(val3);
38747 {
38748 arg4 = wxString_in_helper(obj3);
38749 if (arg4 == NULL) SWIG_fail;
38750 temp4 = true;
38751 }
38752 if (obj4) {
38753 {
38754 arg5 = wxString_in_helper(obj4);
38755 if (arg5 == NULL) SWIG_fail;
38756 temp5 = true;
38757 }
38758 }
38759 if (obj5) {
38760 ecode6 = SWIG_AsVal_int(obj5, &val6);
38761 if (!SWIG_IsOK(ecode6)) {
38762 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38763 }
38764 arg6 = static_cast< wxItemKind >(val6);
38765 }
38766 {
38767 PyThreadState* __tstate = wxPyBeginAllowThreads();
38768 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38769 wxPyEndAllowThreads(__tstate);
38770 if (PyErr_Occurred()) SWIG_fail;
38771 }
38772 {
38773 resultobj = wxPyMake_wxObject(result, (bool)0);
38774 }
38775 {
38776 if (temp4)
38777 delete arg4;
38778 }
38779 {
38780 if (temp5)
38781 delete arg5;
38782 }
38783 return resultobj;
38784 fail:
38785 {
38786 if (temp4)
38787 delete arg4;
38788 }
38789 {
38790 if (temp5)
38791 delete arg5;
38792 }
38793 return NULL;
38794 }
38795
38796
38797 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38798 PyObject *resultobj = 0;
38799 wxMenu *arg1 = (wxMenu *) 0 ;
38800 size_t arg2 ;
38801 wxMenuItem *result = 0 ;
38802 void *argp1 = 0 ;
38803 int res1 = 0 ;
38804 size_t val2 ;
38805 int ecode2 = 0 ;
38806 PyObject * obj0 = 0 ;
38807 PyObject * obj1 = 0 ;
38808 char * kwnames[] = {
38809 (char *) "self",(char *) "pos", NULL
38810 };
38811
38812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38814 if (!SWIG_IsOK(res1)) {
38815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38816 }
38817 arg1 = reinterpret_cast< wxMenu * >(argp1);
38818 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38819 if (!SWIG_IsOK(ecode2)) {
38820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38821 }
38822 arg2 = static_cast< size_t >(val2);
38823 {
38824 PyThreadState* __tstate = wxPyBeginAllowThreads();
38825 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38826 wxPyEndAllowThreads(__tstate);
38827 if (PyErr_Occurred()) SWIG_fail;
38828 }
38829 {
38830 resultobj = wxPyMake_wxObject(result, (bool)0);
38831 }
38832 return resultobj;
38833 fail:
38834 return NULL;
38835 }
38836
38837
38838 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38839 PyObject *resultobj = 0;
38840 wxMenu *arg1 = (wxMenu *) 0 ;
38841 size_t arg2 ;
38842 int arg3 ;
38843 wxString *arg4 = 0 ;
38844 wxString const &arg5_defvalue = wxPyEmptyString ;
38845 wxString *arg5 = (wxString *) &arg5_defvalue ;
38846 wxMenuItem *result = 0 ;
38847 void *argp1 = 0 ;
38848 int res1 = 0 ;
38849 size_t val2 ;
38850 int ecode2 = 0 ;
38851 int val3 ;
38852 int ecode3 = 0 ;
38853 bool temp4 = false ;
38854 bool temp5 = false ;
38855 PyObject * obj0 = 0 ;
38856 PyObject * obj1 = 0 ;
38857 PyObject * obj2 = 0 ;
38858 PyObject * obj3 = 0 ;
38859 PyObject * obj4 = 0 ;
38860 char * kwnames[] = {
38861 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38862 };
38863
38864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38866 if (!SWIG_IsOK(res1)) {
38867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38868 }
38869 arg1 = reinterpret_cast< wxMenu * >(argp1);
38870 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38871 if (!SWIG_IsOK(ecode2)) {
38872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38873 }
38874 arg2 = static_cast< size_t >(val2);
38875 ecode3 = SWIG_AsVal_int(obj2, &val3);
38876 if (!SWIG_IsOK(ecode3)) {
38877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38878 }
38879 arg3 = static_cast< int >(val3);
38880 {
38881 arg4 = wxString_in_helper(obj3);
38882 if (arg4 == NULL) SWIG_fail;
38883 temp4 = true;
38884 }
38885 if (obj4) {
38886 {
38887 arg5 = wxString_in_helper(obj4);
38888 if (arg5 == NULL) SWIG_fail;
38889 temp5 = true;
38890 }
38891 }
38892 {
38893 PyThreadState* __tstate = wxPyBeginAllowThreads();
38894 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38895 wxPyEndAllowThreads(__tstate);
38896 if (PyErr_Occurred()) SWIG_fail;
38897 }
38898 {
38899 resultobj = wxPyMake_wxObject(result, (bool)0);
38900 }
38901 {
38902 if (temp4)
38903 delete arg4;
38904 }
38905 {
38906 if (temp5)
38907 delete arg5;
38908 }
38909 return resultobj;
38910 fail:
38911 {
38912 if (temp4)
38913 delete arg4;
38914 }
38915 {
38916 if (temp5)
38917 delete arg5;
38918 }
38919 return NULL;
38920 }
38921
38922
38923 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38924 PyObject *resultobj = 0;
38925 wxMenu *arg1 = (wxMenu *) 0 ;
38926 size_t arg2 ;
38927 int arg3 ;
38928 wxString *arg4 = 0 ;
38929 wxString const &arg5_defvalue = wxPyEmptyString ;
38930 wxString *arg5 = (wxString *) &arg5_defvalue ;
38931 wxMenuItem *result = 0 ;
38932 void *argp1 = 0 ;
38933 int res1 = 0 ;
38934 size_t val2 ;
38935 int ecode2 = 0 ;
38936 int val3 ;
38937 int ecode3 = 0 ;
38938 bool temp4 = false ;
38939 bool temp5 = false ;
38940 PyObject * obj0 = 0 ;
38941 PyObject * obj1 = 0 ;
38942 PyObject * obj2 = 0 ;
38943 PyObject * obj3 = 0 ;
38944 PyObject * obj4 = 0 ;
38945 char * kwnames[] = {
38946 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38947 };
38948
38949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38951 if (!SWIG_IsOK(res1)) {
38952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38953 }
38954 arg1 = reinterpret_cast< wxMenu * >(argp1);
38955 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38956 if (!SWIG_IsOK(ecode2)) {
38957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38958 }
38959 arg2 = static_cast< size_t >(val2);
38960 ecode3 = SWIG_AsVal_int(obj2, &val3);
38961 if (!SWIG_IsOK(ecode3)) {
38962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38963 }
38964 arg3 = static_cast< int >(val3);
38965 {
38966 arg4 = wxString_in_helper(obj3);
38967 if (arg4 == NULL) SWIG_fail;
38968 temp4 = true;
38969 }
38970 if (obj4) {
38971 {
38972 arg5 = wxString_in_helper(obj4);
38973 if (arg5 == NULL) SWIG_fail;
38974 temp5 = true;
38975 }
38976 }
38977 {
38978 PyThreadState* __tstate = wxPyBeginAllowThreads();
38979 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38980 wxPyEndAllowThreads(__tstate);
38981 if (PyErr_Occurred()) SWIG_fail;
38982 }
38983 {
38984 resultobj = wxPyMake_wxObject(result, (bool)0);
38985 }
38986 {
38987 if (temp4)
38988 delete arg4;
38989 }
38990 {
38991 if (temp5)
38992 delete arg5;
38993 }
38994 return resultobj;
38995 fail:
38996 {
38997 if (temp4)
38998 delete arg4;
38999 }
39000 {
39001 if (temp5)
39002 delete arg5;
39003 }
39004 return NULL;
39005 }
39006
39007
39008 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39009 PyObject *resultobj = 0;
39010 wxMenu *arg1 = (wxMenu *) 0 ;
39011 size_t arg2 ;
39012 int arg3 ;
39013 wxString *arg4 = 0 ;
39014 wxMenu *arg5 = (wxMenu *) 0 ;
39015 wxString const &arg6_defvalue = wxPyEmptyString ;
39016 wxString *arg6 = (wxString *) &arg6_defvalue ;
39017 wxMenuItem *result = 0 ;
39018 void *argp1 = 0 ;
39019 int res1 = 0 ;
39020 size_t val2 ;
39021 int ecode2 = 0 ;
39022 int val3 ;
39023 int ecode3 = 0 ;
39024 bool temp4 = false ;
39025 void *argp5 = 0 ;
39026 int res5 = 0 ;
39027 bool temp6 = false ;
39028 PyObject * obj0 = 0 ;
39029 PyObject * obj1 = 0 ;
39030 PyObject * obj2 = 0 ;
39031 PyObject * obj3 = 0 ;
39032 PyObject * obj4 = 0 ;
39033 PyObject * obj5 = 0 ;
39034 char * kwnames[] = {
39035 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39036 };
39037
39038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39040 if (!SWIG_IsOK(res1)) {
39041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39042 }
39043 arg1 = reinterpret_cast< wxMenu * >(argp1);
39044 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39045 if (!SWIG_IsOK(ecode2)) {
39046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39047 }
39048 arg2 = static_cast< size_t >(val2);
39049 ecode3 = SWIG_AsVal_int(obj2, &val3);
39050 if (!SWIG_IsOK(ecode3)) {
39051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39052 }
39053 arg3 = static_cast< int >(val3);
39054 {
39055 arg4 = wxString_in_helper(obj3);
39056 if (arg4 == NULL) SWIG_fail;
39057 temp4 = true;
39058 }
39059 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39060 if (!SWIG_IsOK(res5)) {
39061 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39062 }
39063 arg5 = reinterpret_cast< wxMenu * >(argp5);
39064 if (obj5) {
39065 {
39066 arg6 = wxString_in_helper(obj5);
39067 if (arg6 == NULL) SWIG_fail;
39068 temp6 = true;
39069 }
39070 }
39071 {
39072 PyThreadState* __tstate = wxPyBeginAllowThreads();
39073 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39074 wxPyEndAllowThreads(__tstate);
39075 if (PyErr_Occurred()) SWIG_fail;
39076 }
39077 {
39078 resultobj = wxPyMake_wxObject(result, (bool)0);
39079 }
39080 {
39081 if (temp4)
39082 delete arg4;
39083 }
39084 {
39085 if (temp6)
39086 delete arg6;
39087 }
39088 return resultobj;
39089 fail:
39090 {
39091 if (temp4)
39092 delete arg4;
39093 }
39094 {
39095 if (temp6)
39096 delete arg6;
39097 }
39098 return NULL;
39099 }
39100
39101
39102 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39103 PyObject *resultobj = 0;
39104 wxMenu *arg1 = (wxMenu *) 0 ;
39105 int arg2 ;
39106 wxString *arg3 = 0 ;
39107 wxString const &arg4_defvalue = wxPyEmptyString ;
39108 wxString *arg4 = (wxString *) &arg4_defvalue ;
39109 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39110 wxMenuItem *result = 0 ;
39111 void *argp1 = 0 ;
39112 int res1 = 0 ;
39113 int val2 ;
39114 int ecode2 = 0 ;
39115 bool temp3 = false ;
39116 bool temp4 = false ;
39117 int val5 ;
39118 int ecode5 = 0 ;
39119 PyObject * obj0 = 0 ;
39120 PyObject * obj1 = 0 ;
39121 PyObject * obj2 = 0 ;
39122 PyObject * obj3 = 0 ;
39123 PyObject * obj4 = 0 ;
39124 char * kwnames[] = {
39125 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39126 };
39127
39128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39130 if (!SWIG_IsOK(res1)) {
39131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39132 }
39133 arg1 = reinterpret_cast< wxMenu * >(argp1);
39134 ecode2 = SWIG_AsVal_int(obj1, &val2);
39135 if (!SWIG_IsOK(ecode2)) {
39136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39137 }
39138 arg2 = static_cast< int >(val2);
39139 {
39140 arg3 = wxString_in_helper(obj2);
39141 if (arg3 == NULL) SWIG_fail;
39142 temp3 = true;
39143 }
39144 if (obj3) {
39145 {
39146 arg4 = wxString_in_helper(obj3);
39147 if (arg4 == NULL) SWIG_fail;
39148 temp4 = true;
39149 }
39150 }
39151 if (obj4) {
39152 ecode5 = SWIG_AsVal_int(obj4, &val5);
39153 if (!SWIG_IsOK(ecode5)) {
39154 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39155 }
39156 arg5 = static_cast< wxItemKind >(val5);
39157 }
39158 {
39159 PyThreadState* __tstate = wxPyBeginAllowThreads();
39160 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39161 wxPyEndAllowThreads(__tstate);
39162 if (PyErr_Occurred()) SWIG_fail;
39163 }
39164 {
39165 resultobj = wxPyMake_wxObject(result, (bool)0);
39166 }
39167 {
39168 if (temp3)
39169 delete arg3;
39170 }
39171 {
39172 if (temp4)
39173 delete arg4;
39174 }
39175 return resultobj;
39176 fail:
39177 {
39178 if (temp3)
39179 delete arg3;
39180 }
39181 {
39182 if (temp4)
39183 delete arg4;
39184 }
39185 return NULL;
39186 }
39187
39188
39189 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39190 PyObject *resultobj = 0;
39191 wxMenu *arg1 = (wxMenu *) 0 ;
39192 wxMenuItem *result = 0 ;
39193 void *argp1 = 0 ;
39194 int res1 = 0 ;
39195 PyObject *swig_obj[1] ;
39196
39197 if (!args) SWIG_fail;
39198 swig_obj[0] = args;
39199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39200 if (!SWIG_IsOK(res1)) {
39201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39202 }
39203 arg1 = reinterpret_cast< wxMenu * >(argp1);
39204 {
39205 PyThreadState* __tstate = wxPyBeginAllowThreads();
39206 result = (wxMenuItem *)(arg1)->PrependSeparator();
39207 wxPyEndAllowThreads(__tstate);
39208 if (PyErr_Occurred()) SWIG_fail;
39209 }
39210 {
39211 resultobj = wxPyMake_wxObject(result, (bool)0);
39212 }
39213 return resultobj;
39214 fail:
39215 return NULL;
39216 }
39217
39218
39219 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39220 PyObject *resultobj = 0;
39221 wxMenu *arg1 = (wxMenu *) 0 ;
39222 int arg2 ;
39223 wxString *arg3 = 0 ;
39224 wxString const &arg4_defvalue = wxPyEmptyString ;
39225 wxString *arg4 = (wxString *) &arg4_defvalue ;
39226 wxMenuItem *result = 0 ;
39227 void *argp1 = 0 ;
39228 int res1 = 0 ;
39229 int val2 ;
39230 int ecode2 = 0 ;
39231 bool temp3 = false ;
39232 bool temp4 = false ;
39233 PyObject * obj0 = 0 ;
39234 PyObject * obj1 = 0 ;
39235 PyObject * obj2 = 0 ;
39236 PyObject * obj3 = 0 ;
39237 char * kwnames[] = {
39238 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39239 };
39240
39241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39243 if (!SWIG_IsOK(res1)) {
39244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39245 }
39246 arg1 = reinterpret_cast< wxMenu * >(argp1);
39247 ecode2 = SWIG_AsVal_int(obj1, &val2);
39248 if (!SWIG_IsOK(ecode2)) {
39249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39250 }
39251 arg2 = static_cast< int >(val2);
39252 {
39253 arg3 = wxString_in_helper(obj2);
39254 if (arg3 == NULL) SWIG_fail;
39255 temp3 = true;
39256 }
39257 if (obj3) {
39258 {
39259 arg4 = wxString_in_helper(obj3);
39260 if (arg4 == NULL) SWIG_fail;
39261 temp4 = true;
39262 }
39263 }
39264 {
39265 PyThreadState* __tstate = wxPyBeginAllowThreads();
39266 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39267 wxPyEndAllowThreads(__tstate);
39268 if (PyErr_Occurred()) SWIG_fail;
39269 }
39270 {
39271 resultobj = wxPyMake_wxObject(result, (bool)0);
39272 }
39273 {
39274 if (temp3)
39275 delete arg3;
39276 }
39277 {
39278 if (temp4)
39279 delete arg4;
39280 }
39281 return resultobj;
39282 fail:
39283 {
39284 if (temp3)
39285 delete arg3;
39286 }
39287 {
39288 if (temp4)
39289 delete arg4;
39290 }
39291 return NULL;
39292 }
39293
39294
39295 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39296 PyObject *resultobj = 0;
39297 wxMenu *arg1 = (wxMenu *) 0 ;
39298 int arg2 ;
39299 wxString *arg3 = 0 ;
39300 wxString const &arg4_defvalue = wxPyEmptyString ;
39301 wxString *arg4 = (wxString *) &arg4_defvalue ;
39302 wxMenuItem *result = 0 ;
39303 void *argp1 = 0 ;
39304 int res1 = 0 ;
39305 int val2 ;
39306 int ecode2 = 0 ;
39307 bool temp3 = false ;
39308 bool temp4 = false ;
39309 PyObject * obj0 = 0 ;
39310 PyObject * obj1 = 0 ;
39311 PyObject * obj2 = 0 ;
39312 PyObject * obj3 = 0 ;
39313 char * kwnames[] = {
39314 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39315 };
39316
39317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39319 if (!SWIG_IsOK(res1)) {
39320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39321 }
39322 arg1 = reinterpret_cast< wxMenu * >(argp1);
39323 ecode2 = SWIG_AsVal_int(obj1, &val2);
39324 if (!SWIG_IsOK(ecode2)) {
39325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39326 }
39327 arg2 = static_cast< int >(val2);
39328 {
39329 arg3 = wxString_in_helper(obj2);
39330 if (arg3 == NULL) SWIG_fail;
39331 temp3 = true;
39332 }
39333 if (obj3) {
39334 {
39335 arg4 = wxString_in_helper(obj3);
39336 if (arg4 == NULL) SWIG_fail;
39337 temp4 = true;
39338 }
39339 }
39340 {
39341 PyThreadState* __tstate = wxPyBeginAllowThreads();
39342 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39343 wxPyEndAllowThreads(__tstate);
39344 if (PyErr_Occurred()) SWIG_fail;
39345 }
39346 {
39347 resultobj = wxPyMake_wxObject(result, (bool)0);
39348 }
39349 {
39350 if (temp3)
39351 delete arg3;
39352 }
39353 {
39354 if (temp4)
39355 delete arg4;
39356 }
39357 return resultobj;
39358 fail:
39359 {
39360 if (temp3)
39361 delete arg3;
39362 }
39363 {
39364 if (temp4)
39365 delete arg4;
39366 }
39367 return NULL;
39368 }
39369
39370
39371 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39372 PyObject *resultobj = 0;
39373 wxMenu *arg1 = (wxMenu *) 0 ;
39374 int arg2 ;
39375 wxString *arg3 = 0 ;
39376 wxMenu *arg4 = (wxMenu *) 0 ;
39377 wxString const &arg5_defvalue = wxPyEmptyString ;
39378 wxString *arg5 = (wxString *) &arg5_defvalue ;
39379 wxMenuItem *result = 0 ;
39380 void *argp1 = 0 ;
39381 int res1 = 0 ;
39382 int val2 ;
39383 int ecode2 = 0 ;
39384 bool temp3 = false ;
39385 void *argp4 = 0 ;
39386 int res4 = 0 ;
39387 bool temp5 = false ;
39388 PyObject * obj0 = 0 ;
39389 PyObject * obj1 = 0 ;
39390 PyObject * obj2 = 0 ;
39391 PyObject * obj3 = 0 ;
39392 PyObject * obj4 = 0 ;
39393 char * kwnames[] = {
39394 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39395 };
39396
39397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39399 if (!SWIG_IsOK(res1)) {
39400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39401 }
39402 arg1 = reinterpret_cast< wxMenu * >(argp1);
39403 ecode2 = SWIG_AsVal_int(obj1, &val2);
39404 if (!SWIG_IsOK(ecode2)) {
39405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39406 }
39407 arg2 = static_cast< int >(val2);
39408 {
39409 arg3 = wxString_in_helper(obj2);
39410 if (arg3 == NULL) SWIG_fail;
39411 temp3 = true;
39412 }
39413 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39414 if (!SWIG_IsOK(res4)) {
39415 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39416 }
39417 arg4 = reinterpret_cast< wxMenu * >(argp4);
39418 if (obj4) {
39419 {
39420 arg5 = wxString_in_helper(obj4);
39421 if (arg5 == NULL) SWIG_fail;
39422 temp5 = true;
39423 }
39424 }
39425 {
39426 PyThreadState* __tstate = wxPyBeginAllowThreads();
39427 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39428 wxPyEndAllowThreads(__tstate);
39429 if (PyErr_Occurred()) SWIG_fail;
39430 }
39431 {
39432 resultobj = wxPyMake_wxObject(result, (bool)0);
39433 }
39434 {
39435 if (temp3)
39436 delete arg3;
39437 }
39438 {
39439 if (temp5)
39440 delete arg5;
39441 }
39442 return resultobj;
39443 fail:
39444 {
39445 if (temp3)
39446 delete arg3;
39447 }
39448 {
39449 if (temp5)
39450 delete arg5;
39451 }
39452 return NULL;
39453 }
39454
39455
39456 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39457 PyObject *resultobj = 0;
39458 wxMenu *arg1 = (wxMenu *) 0 ;
39459 int arg2 ;
39460 wxMenuItem *result = 0 ;
39461 void *argp1 = 0 ;
39462 int res1 = 0 ;
39463 int val2 ;
39464 int ecode2 = 0 ;
39465 PyObject * obj0 = 0 ;
39466 PyObject * obj1 = 0 ;
39467 char * kwnames[] = {
39468 (char *) "self",(char *) "id", NULL
39469 };
39470
39471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39473 if (!SWIG_IsOK(res1)) {
39474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39475 }
39476 arg1 = reinterpret_cast< wxMenu * >(argp1);
39477 ecode2 = SWIG_AsVal_int(obj1, &val2);
39478 if (!SWIG_IsOK(ecode2)) {
39479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39480 }
39481 arg2 = static_cast< int >(val2);
39482 {
39483 PyThreadState* __tstate = wxPyBeginAllowThreads();
39484 result = (wxMenuItem *)(arg1)->Remove(arg2);
39485 wxPyEndAllowThreads(__tstate);
39486 if (PyErr_Occurred()) SWIG_fail;
39487 }
39488 {
39489 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39490 }
39491 return resultobj;
39492 fail:
39493 return NULL;
39494 }
39495
39496
39497 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39498 PyObject *resultobj = 0;
39499 wxMenu *arg1 = (wxMenu *) 0 ;
39500 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39501 wxMenuItem *result = 0 ;
39502 void *argp1 = 0 ;
39503 int res1 = 0 ;
39504 void *argp2 = 0 ;
39505 int res2 = 0 ;
39506 PyObject * obj0 = 0 ;
39507 PyObject * obj1 = 0 ;
39508 char * kwnames[] = {
39509 (char *) "self",(char *) "item", NULL
39510 };
39511
39512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39514 if (!SWIG_IsOK(res1)) {
39515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39516 }
39517 arg1 = reinterpret_cast< wxMenu * >(argp1);
39518 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39519 if (!SWIG_IsOK(res2)) {
39520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39521 }
39522 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39523 {
39524 PyThreadState* __tstate = wxPyBeginAllowThreads();
39525 result = (wxMenuItem *)(arg1)->Remove(arg2);
39526 wxPyEndAllowThreads(__tstate);
39527 if (PyErr_Occurred()) SWIG_fail;
39528 }
39529 {
39530 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39531 }
39532 return resultobj;
39533 fail:
39534 return NULL;
39535 }
39536
39537
39538 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39539 PyObject *resultobj = 0;
39540 wxMenu *arg1 = (wxMenu *) 0 ;
39541 int arg2 ;
39542 bool result;
39543 void *argp1 = 0 ;
39544 int res1 = 0 ;
39545 int val2 ;
39546 int ecode2 = 0 ;
39547 PyObject * obj0 = 0 ;
39548 PyObject * obj1 = 0 ;
39549 char * kwnames[] = {
39550 (char *) "self",(char *) "id", NULL
39551 };
39552
39553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39555 if (!SWIG_IsOK(res1)) {
39556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39557 }
39558 arg1 = reinterpret_cast< wxMenu * >(argp1);
39559 ecode2 = SWIG_AsVal_int(obj1, &val2);
39560 if (!SWIG_IsOK(ecode2)) {
39561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39562 }
39563 arg2 = static_cast< int >(val2);
39564 {
39565 PyThreadState* __tstate = wxPyBeginAllowThreads();
39566 result = (bool)(arg1)->Delete(arg2);
39567 wxPyEndAllowThreads(__tstate);
39568 if (PyErr_Occurred()) SWIG_fail;
39569 }
39570 {
39571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39572 }
39573 return resultobj;
39574 fail:
39575 return NULL;
39576 }
39577
39578
39579 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39580 PyObject *resultobj = 0;
39581 wxMenu *arg1 = (wxMenu *) 0 ;
39582 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39583 bool result;
39584 void *argp1 = 0 ;
39585 int res1 = 0 ;
39586 void *argp2 = 0 ;
39587 int res2 = 0 ;
39588 PyObject * obj0 = 0 ;
39589 PyObject * obj1 = 0 ;
39590 char * kwnames[] = {
39591 (char *) "self",(char *) "item", NULL
39592 };
39593
39594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39596 if (!SWIG_IsOK(res1)) {
39597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39598 }
39599 arg1 = reinterpret_cast< wxMenu * >(argp1);
39600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39601 if (!SWIG_IsOK(res2)) {
39602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39603 }
39604 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39605 {
39606 PyThreadState* __tstate = wxPyBeginAllowThreads();
39607 result = (bool)(arg1)->Delete(arg2);
39608 wxPyEndAllowThreads(__tstate);
39609 if (PyErr_Occurred()) SWIG_fail;
39610 }
39611 {
39612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39613 }
39614 return resultobj;
39615 fail:
39616 return NULL;
39617 }
39618
39619
39620 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39621 PyObject *resultobj = 0;
39622 wxMenu *arg1 = (wxMenu *) 0 ;
39623 void *argp1 = 0 ;
39624 int res1 = 0 ;
39625 PyObject *swig_obj[1] ;
39626
39627 if (!args) SWIG_fail;
39628 swig_obj[0] = args;
39629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39630 if (!SWIG_IsOK(res1)) {
39631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39632 }
39633 arg1 = reinterpret_cast< wxMenu * >(argp1);
39634 {
39635 PyThreadState* __tstate = wxPyBeginAllowThreads();
39636 wxMenu_Destroy(arg1);
39637 wxPyEndAllowThreads(__tstate);
39638 if (PyErr_Occurred()) SWIG_fail;
39639 }
39640 resultobj = SWIG_Py_Void();
39641 return resultobj;
39642 fail:
39643 return NULL;
39644 }
39645
39646
39647 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39648 PyObject *resultobj = 0;
39649 wxMenu *arg1 = (wxMenu *) 0 ;
39650 int arg2 ;
39651 bool result;
39652 void *argp1 = 0 ;
39653 int res1 = 0 ;
39654 int val2 ;
39655 int ecode2 = 0 ;
39656 PyObject * obj0 = 0 ;
39657 PyObject * obj1 = 0 ;
39658 char * kwnames[] = {
39659 (char *) "self",(char *) "id", NULL
39660 };
39661
39662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39664 if (!SWIG_IsOK(res1)) {
39665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39666 }
39667 arg1 = reinterpret_cast< wxMenu * >(argp1);
39668 ecode2 = SWIG_AsVal_int(obj1, &val2);
39669 if (!SWIG_IsOK(ecode2)) {
39670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39671 }
39672 arg2 = static_cast< int >(val2);
39673 {
39674 PyThreadState* __tstate = wxPyBeginAllowThreads();
39675 result = (bool)(arg1)->Destroy(arg2);
39676 wxPyEndAllowThreads(__tstate);
39677 if (PyErr_Occurred()) SWIG_fail;
39678 }
39679 {
39680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39681 }
39682 return resultobj;
39683 fail:
39684 return NULL;
39685 }
39686
39687
39688 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39689 PyObject *resultobj = 0;
39690 wxMenu *arg1 = (wxMenu *) 0 ;
39691 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39692 bool result;
39693 void *argp1 = 0 ;
39694 int res1 = 0 ;
39695 void *argp2 = 0 ;
39696 int res2 = 0 ;
39697 PyObject * obj0 = 0 ;
39698 PyObject * obj1 = 0 ;
39699 char * kwnames[] = {
39700 (char *) "self",(char *) "item", NULL
39701 };
39702
39703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39705 if (!SWIG_IsOK(res1)) {
39706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39707 }
39708 arg1 = reinterpret_cast< wxMenu * >(argp1);
39709 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39710 if (!SWIG_IsOK(res2)) {
39711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39712 }
39713 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39714 {
39715 PyThreadState* __tstate = wxPyBeginAllowThreads();
39716 result = (bool)(arg1)->Destroy(arg2);
39717 wxPyEndAllowThreads(__tstate);
39718 if (PyErr_Occurred()) SWIG_fail;
39719 }
39720 {
39721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39722 }
39723 return resultobj;
39724 fail:
39725 return NULL;
39726 }
39727
39728
39729 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39730 PyObject *resultobj = 0;
39731 wxMenu *arg1 = (wxMenu *) 0 ;
39732 size_t result;
39733 void *argp1 = 0 ;
39734 int res1 = 0 ;
39735 PyObject *swig_obj[1] ;
39736
39737 if (!args) SWIG_fail;
39738 swig_obj[0] = args;
39739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39740 if (!SWIG_IsOK(res1)) {
39741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39742 }
39743 arg1 = reinterpret_cast< wxMenu * >(argp1);
39744 {
39745 PyThreadState* __tstate = wxPyBeginAllowThreads();
39746 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39747 wxPyEndAllowThreads(__tstate);
39748 if (PyErr_Occurred()) SWIG_fail;
39749 }
39750 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39751 return resultobj;
39752 fail:
39753 return NULL;
39754 }
39755
39756
39757 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39758 PyObject *resultobj = 0;
39759 wxMenu *arg1 = (wxMenu *) 0 ;
39760 PyObject *result = 0 ;
39761 void *argp1 = 0 ;
39762 int res1 = 0 ;
39763 PyObject *swig_obj[1] ;
39764
39765 if (!args) SWIG_fail;
39766 swig_obj[0] = args;
39767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39768 if (!SWIG_IsOK(res1)) {
39769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39770 }
39771 arg1 = reinterpret_cast< wxMenu * >(argp1);
39772 {
39773 PyThreadState* __tstate = wxPyBeginAllowThreads();
39774 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39775 wxPyEndAllowThreads(__tstate);
39776 if (PyErr_Occurred()) SWIG_fail;
39777 }
39778 resultobj = result;
39779 return resultobj;
39780 fail:
39781 return NULL;
39782 }
39783
39784
39785 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39786 PyObject *resultobj = 0;
39787 wxMenu *arg1 = (wxMenu *) 0 ;
39788 wxString *arg2 = 0 ;
39789 int result;
39790 void *argp1 = 0 ;
39791 int res1 = 0 ;
39792 bool temp2 = false ;
39793 PyObject * obj0 = 0 ;
39794 PyObject * obj1 = 0 ;
39795 char * kwnames[] = {
39796 (char *) "self",(char *) "item", NULL
39797 };
39798
39799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39801 if (!SWIG_IsOK(res1)) {
39802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39803 }
39804 arg1 = reinterpret_cast< wxMenu * >(argp1);
39805 {
39806 arg2 = wxString_in_helper(obj1);
39807 if (arg2 == NULL) SWIG_fail;
39808 temp2 = true;
39809 }
39810 {
39811 PyThreadState* __tstate = wxPyBeginAllowThreads();
39812 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39813 wxPyEndAllowThreads(__tstate);
39814 if (PyErr_Occurred()) SWIG_fail;
39815 }
39816 resultobj = SWIG_From_int(static_cast< int >(result));
39817 {
39818 if (temp2)
39819 delete arg2;
39820 }
39821 return resultobj;
39822 fail:
39823 {
39824 if (temp2)
39825 delete arg2;
39826 }
39827 return NULL;
39828 }
39829
39830
39831 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39832 PyObject *resultobj = 0;
39833 wxMenu *arg1 = (wxMenu *) 0 ;
39834 int arg2 ;
39835 wxMenuItem *result = 0 ;
39836 void *argp1 = 0 ;
39837 int res1 = 0 ;
39838 int val2 ;
39839 int ecode2 = 0 ;
39840 PyObject * obj0 = 0 ;
39841 PyObject * obj1 = 0 ;
39842 char * kwnames[] = {
39843 (char *) "self",(char *) "id", NULL
39844 };
39845
39846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39848 if (!SWIG_IsOK(res1)) {
39849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39850 }
39851 arg1 = reinterpret_cast< wxMenu * >(argp1);
39852 ecode2 = SWIG_AsVal_int(obj1, &val2);
39853 if (!SWIG_IsOK(ecode2)) {
39854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39855 }
39856 arg2 = static_cast< int >(val2);
39857 {
39858 PyThreadState* __tstate = wxPyBeginAllowThreads();
39859 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39860 wxPyEndAllowThreads(__tstate);
39861 if (PyErr_Occurred()) SWIG_fail;
39862 }
39863 {
39864 resultobj = wxPyMake_wxObject(result, (bool)0);
39865 }
39866 return resultobj;
39867 fail:
39868 return NULL;
39869 }
39870
39871
39872 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39873 PyObject *resultobj = 0;
39874 wxMenu *arg1 = (wxMenu *) 0 ;
39875 size_t arg2 ;
39876 wxMenuItem *result = 0 ;
39877 void *argp1 = 0 ;
39878 int res1 = 0 ;
39879 size_t val2 ;
39880 int ecode2 = 0 ;
39881 PyObject * obj0 = 0 ;
39882 PyObject * obj1 = 0 ;
39883 char * kwnames[] = {
39884 (char *) "self",(char *) "position", NULL
39885 };
39886
39887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39889 if (!SWIG_IsOK(res1)) {
39890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39891 }
39892 arg1 = reinterpret_cast< wxMenu * >(argp1);
39893 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39894 if (!SWIG_IsOK(ecode2)) {
39895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39896 }
39897 arg2 = static_cast< size_t >(val2);
39898 {
39899 PyThreadState* __tstate = wxPyBeginAllowThreads();
39900 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39901 wxPyEndAllowThreads(__tstate);
39902 if (PyErr_Occurred()) SWIG_fail;
39903 }
39904 {
39905 resultobj = wxPyMake_wxObject(result, (bool)0);
39906 }
39907 return resultobj;
39908 fail:
39909 return NULL;
39910 }
39911
39912
39913 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39914 PyObject *resultobj = 0;
39915 wxMenu *arg1 = (wxMenu *) 0 ;
39916 int arg2 ;
39917 bool arg3 ;
39918 void *argp1 = 0 ;
39919 int res1 = 0 ;
39920 int val2 ;
39921 int ecode2 = 0 ;
39922 bool val3 ;
39923 int ecode3 = 0 ;
39924 PyObject * obj0 = 0 ;
39925 PyObject * obj1 = 0 ;
39926 PyObject * obj2 = 0 ;
39927 char * kwnames[] = {
39928 (char *) "self",(char *) "id",(char *) "enable", NULL
39929 };
39930
39931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39933 if (!SWIG_IsOK(res1)) {
39934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39935 }
39936 arg1 = reinterpret_cast< wxMenu * >(argp1);
39937 ecode2 = SWIG_AsVal_int(obj1, &val2);
39938 if (!SWIG_IsOK(ecode2)) {
39939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39940 }
39941 arg2 = static_cast< int >(val2);
39942 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39943 if (!SWIG_IsOK(ecode3)) {
39944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39945 }
39946 arg3 = static_cast< bool >(val3);
39947 {
39948 PyThreadState* __tstate = wxPyBeginAllowThreads();
39949 (arg1)->Enable(arg2,arg3);
39950 wxPyEndAllowThreads(__tstate);
39951 if (PyErr_Occurred()) SWIG_fail;
39952 }
39953 resultobj = SWIG_Py_Void();
39954 return resultobj;
39955 fail:
39956 return NULL;
39957 }
39958
39959
39960 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39961 PyObject *resultobj = 0;
39962 wxMenu *arg1 = (wxMenu *) 0 ;
39963 int arg2 ;
39964 bool result;
39965 void *argp1 = 0 ;
39966 int res1 = 0 ;
39967 int val2 ;
39968 int ecode2 = 0 ;
39969 PyObject * obj0 = 0 ;
39970 PyObject * obj1 = 0 ;
39971 char * kwnames[] = {
39972 (char *) "self",(char *) "id", NULL
39973 };
39974
39975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39977 if (!SWIG_IsOK(res1)) {
39978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39979 }
39980 arg1 = reinterpret_cast< wxMenu * >(argp1);
39981 ecode2 = SWIG_AsVal_int(obj1, &val2);
39982 if (!SWIG_IsOK(ecode2)) {
39983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39984 }
39985 arg2 = static_cast< int >(val2);
39986 {
39987 PyThreadState* __tstate = wxPyBeginAllowThreads();
39988 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39989 wxPyEndAllowThreads(__tstate);
39990 if (PyErr_Occurred()) SWIG_fail;
39991 }
39992 {
39993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39994 }
39995 return resultobj;
39996 fail:
39997 return NULL;
39998 }
39999
40000
40001 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40002 PyObject *resultobj = 0;
40003 wxMenu *arg1 = (wxMenu *) 0 ;
40004 int arg2 ;
40005 bool arg3 ;
40006 void *argp1 = 0 ;
40007 int res1 = 0 ;
40008 int val2 ;
40009 int ecode2 = 0 ;
40010 bool val3 ;
40011 int ecode3 = 0 ;
40012 PyObject * obj0 = 0 ;
40013 PyObject * obj1 = 0 ;
40014 PyObject * obj2 = 0 ;
40015 char * kwnames[] = {
40016 (char *) "self",(char *) "id",(char *) "check", NULL
40017 };
40018
40019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40021 if (!SWIG_IsOK(res1)) {
40022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40023 }
40024 arg1 = reinterpret_cast< wxMenu * >(argp1);
40025 ecode2 = SWIG_AsVal_int(obj1, &val2);
40026 if (!SWIG_IsOK(ecode2)) {
40027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40028 }
40029 arg2 = static_cast< int >(val2);
40030 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40031 if (!SWIG_IsOK(ecode3)) {
40032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40033 }
40034 arg3 = static_cast< bool >(val3);
40035 {
40036 PyThreadState* __tstate = wxPyBeginAllowThreads();
40037 (arg1)->Check(arg2,arg3);
40038 wxPyEndAllowThreads(__tstate);
40039 if (PyErr_Occurred()) SWIG_fail;
40040 }
40041 resultobj = SWIG_Py_Void();
40042 return resultobj;
40043 fail:
40044 return NULL;
40045 }
40046
40047
40048 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40049 PyObject *resultobj = 0;
40050 wxMenu *arg1 = (wxMenu *) 0 ;
40051 int arg2 ;
40052 bool result;
40053 void *argp1 = 0 ;
40054 int res1 = 0 ;
40055 int val2 ;
40056 int ecode2 = 0 ;
40057 PyObject * obj0 = 0 ;
40058 PyObject * obj1 = 0 ;
40059 char * kwnames[] = {
40060 (char *) "self",(char *) "id", NULL
40061 };
40062
40063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40065 if (!SWIG_IsOK(res1)) {
40066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40067 }
40068 arg1 = reinterpret_cast< wxMenu * >(argp1);
40069 ecode2 = SWIG_AsVal_int(obj1, &val2);
40070 if (!SWIG_IsOK(ecode2)) {
40071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40072 }
40073 arg2 = static_cast< int >(val2);
40074 {
40075 PyThreadState* __tstate = wxPyBeginAllowThreads();
40076 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40077 wxPyEndAllowThreads(__tstate);
40078 if (PyErr_Occurred()) SWIG_fail;
40079 }
40080 {
40081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40082 }
40083 return resultobj;
40084 fail:
40085 return NULL;
40086 }
40087
40088
40089 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40090 PyObject *resultobj = 0;
40091 wxMenu *arg1 = (wxMenu *) 0 ;
40092 int arg2 ;
40093 wxString *arg3 = 0 ;
40094 void *argp1 = 0 ;
40095 int res1 = 0 ;
40096 int val2 ;
40097 int ecode2 = 0 ;
40098 bool temp3 = false ;
40099 PyObject * obj0 = 0 ;
40100 PyObject * obj1 = 0 ;
40101 PyObject * obj2 = 0 ;
40102 char * kwnames[] = {
40103 (char *) "self",(char *) "id",(char *) "label", NULL
40104 };
40105
40106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40108 if (!SWIG_IsOK(res1)) {
40109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40110 }
40111 arg1 = reinterpret_cast< wxMenu * >(argp1);
40112 ecode2 = SWIG_AsVal_int(obj1, &val2);
40113 if (!SWIG_IsOK(ecode2)) {
40114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40115 }
40116 arg2 = static_cast< int >(val2);
40117 {
40118 arg3 = wxString_in_helper(obj2);
40119 if (arg3 == NULL) SWIG_fail;
40120 temp3 = true;
40121 }
40122 {
40123 PyThreadState* __tstate = wxPyBeginAllowThreads();
40124 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40125 wxPyEndAllowThreads(__tstate);
40126 if (PyErr_Occurred()) SWIG_fail;
40127 }
40128 resultobj = SWIG_Py_Void();
40129 {
40130 if (temp3)
40131 delete arg3;
40132 }
40133 return resultobj;
40134 fail:
40135 {
40136 if (temp3)
40137 delete arg3;
40138 }
40139 return NULL;
40140 }
40141
40142
40143 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40144 PyObject *resultobj = 0;
40145 wxMenu *arg1 = (wxMenu *) 0 ;
40146 int arg2 ;
40147 wxString result;
40148 void *argp1 = 0 ;
40149 int res1 = 0 ;
40150 int val2 ;
40151 int ecode2 = 0 ;
40152 PyObject * obj0 = 0 ;
40153 PyObject * obj1 = 0 ;
40154 char * kwnames[] = {
40155 (char *) "self",(char *) "id", NULL
40156 };
40157
40158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40160 if (!SWIG_IsOK(res1)) {
40161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40162 }
40163 arg1 = reinterpret_cast< wxMenu * >(argp1);
40164 ecode2 = SWIG_AsVal_int(obj1, &val2);
40165 if (!SWIG_IsOK(ecode2)) {
40166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40167 }
40168 arg2 = static_cast< int >(val2);
40169 {
40170 PyThreadState* __tstate = wxPyBeginAllowThreads();
40171 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40172 wxPyEndAllowThreads(__tstate);
40173 if (PyErr_Occurred()) SWIG_fail;
40174 }
40175 {
40176 #if wxUSE_UNICODE
40177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40178 #else
40179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40180 #endif
40181 }
40182 return resultobj;
40183 fail:
40184 return NULL;
40185 }
40186
40187
40188 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40189 PyObject *resultobj = 0;
40190 wxMenu *arg1 = (wxMenu *) 0 ;
40191 int arg2 ;
40192 wxString *arg3 = 0 ;
40193 void *argp1 = 0 ;
40194 int res1 = 0 ;
40195 int val2 ;
40196 int ecode2 = 0 ;
40197 bool temp3 = false ;
40198 PyObject * obj0 = 0 ;
40199 PyObject * obj1 = 0 ;
40200 PyObject * obj2 = 0 ;
40201 char * kwnames[] = {
40202 (char *) "self",(char *) "id",(char *) "helpString", NULL
40203 };
40204
40205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40207 if (!SWIG_IsOK(res1)) {
40208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40209 }
40210 arg1 = reinterpret_cast< wxMenu * >(argp1);
40211 ecode2 = SWIG_AsVal_int(obj1, &val2);
40212 if (!SWIG_IsOK(ecode2)) {
40213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40214 }
40215 arg2 = static_cast< int >(val2);
40216 {
40217 arg3 = wxString_in_helper(obj2);
40218 if (arg3 == NULL) SWIG_fail;
40219 temp3 = true;
40220 }
40221 {
40222 PyThreadState* __tstate = wxPyBeginAllowThreads();
40223 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40224 wxPyEndAllowThreads(__tstate);
40225 if (PyErr_Occurred()) SWIG_fail;
40226 }
40227 resultobj = SWIG_Py_Void();
40228 {
40229 if (temp3)
40230 delete arg3;
40231 }
40232 return resultobj;
40233 fail:
40234 {
40235 if (temp3)
40236 delete arg3;
40237 }
40238 return NULL;
40239 }
40240
40241
40242 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40243 PyObject *resultobj = 0;
40244 wxMenu *arg1 = (wxMenu *) 0 ;
40245 int arg2 ;
40246 wxString result;
40247 void *argp1 = 0 ;
40248 int res1 = 0 ;
40249 int val2 ;
40250 int ecode2 = 0 ;
40251 PyObject * obj0 = 0 ;
40252 PyObject * obj1 = 0 ;
40253 char * kwnames[] = {
40254 (char *) "self",(char *) "id", NULL
40255 };
40256
40257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40259 if (!SWIG_IsOK(res1)) {
40260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40261 }
40262 arg1 = reinterpret_cast< wxMenu * >(argp1);
40263 ecode2 = SWIG_AsVal_int(obj1, &val2);
40264 if (!SWIG_IsOK(ecode2)) {
40265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40266 }
40267 arg2 = static_cast< int >(val2);
40268 {
40269 PyThreadState* __tstate = wxPyBeginAllowThreads();
40270 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40271 wxPyEndAllowThreads(__tstate);
40272 if (PyErr_Occurred()) SWIG_fail;
40273 }
40274 {
40275 #if wxUSE_UNICODE
40276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40277 #else
40278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40279 #endif
40280 }
40281 return resultobj;
40282 fail:
40283 return NULL;
40284 }
40285
40286
40287 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40288 PyObject *resultobj = 0;
40289 wxMenu *arg1 = (wxMenu *) 0 ;
40290 wxString *arg2 = 0 ;
40291 void *argp1 = 0 ;
40292 int res1 = 0 ;
40293 bool temp2 = false ;
40294 PyObject * obj0 = 0 ;
40295 PyObject * obj1 = 0 ;
40296 char * kwnames[] = {
40297 (char *) "self",(char *) "title", NULL
40298 };
40299
40300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40302 if (!SWIG_IsOK(res1)) {
40303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40304 }
40305 arg1 = reinterpret_cast< wxMenu * >(argp1);
40306 {
40307 arg2 = wxString_in_helper(obj1);
40308 if (arg2 == NULL) SWIG_fail;
40309 temp2 = true;
40310 }
40311 {
40312 PyThreadState* __tstate = wxPyBeginAllowThreads();
40313 (arg1)->SetTitle((wxString const &)*arg2);
40314 wxPyEndAllowThreads(__tstate);
40315 if (PyErr_Occurred()) SWIG_fail;
40316 }
40317 resultobj = SWIG_Py_Void();
40318 {
40319 if (temp2)
40320 delete arg2;
40321 }
40322 return resultobj;
40323 fail:
40324 {
40325 if (temp2)
40326 delete arg2;
40327 }
40328 return NULL;
40329 }
40330
40331
40332 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40333 PyObject *resultobj = 0;
40334 wxMenu *arg1 = (wxMenu *) 0 ;
40335 wxString result;
40336 void *argp1 = 0 ;
40337 int res1 = 0 ;
40338 PyObject *swig_obj[1] ;
40339
40340 if (!args) SWIG_fail;
40341 swig_obj[0] = args;
40342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40343 if (!SWIG_IsOK(res1)) {
40344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40345 }
40346 arg1 = reinterpret_cast< wxMenu * >(argp1);
40347 {
40348 PyThreadState* __tstate = wxPyBeginAllowThreads();
40349 result = ((wxMenu const *)arg1)->GetTitle();
40350 wxPyEndAllowThreads(__tstate);
40351 if (PyErr_Occurred()) SWIG_fail;
40352 }
40353 {
40354 #if wxUSE_UNICODE
40355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40356 #else
40357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40358 #endif
40359 }
40360 return resultobj;
40361 fail:
40362 return NULL;
40363 }
40364
40365
40366 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40367 PyObject *resultobj = 0;
40368 wxMenu *arg1 = (wxMenu *) 0 ;
40369 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40370 void *argp1 = 0 ;
40371 int res1 = 0 ;
40372 void *argp2 = 0 ;
40373 int res2 = 0 ;
40374 PyObject * obj0 = 0 ;
40375 PyObject * obj1 = 0 ;
40376 char * kwnames[] = {
40377 (char *) "self",(char *) "handler", NULL
40378 };
40379
40380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40382 if (!SWIG_IsOK(res1)) {
40383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40384 }
40385 arg1 = reinterpret_cast< wxMenu * >(argp1);
40386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40387 if (!SWIG_IsOK(res2)) {
40388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40389 }
40390 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40391 {
40392 PyThreadState* __tstate = wxPyBeginAllowThreads();
40393 (arg1)->SetEventHandler(arg2);
40394 wxPyEndAllowThreads(__tstate);
40395 if (PyErr_Occurred()) SWIG_fail;
40396 }
40397 resultobj = SWIG_Py_Void();
40398 return resultobj;
40399 fail:
40400 return NULL;
40401 }
40402
40403
40404 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40405 PyObject *resultobj = 0;
40406 wxMenu *arg1 = (wxMenu *) 0 ;
40407 wxEvtHandler *result = 0 ;
40408 void *argp1 = 0 ;
40409 int res1 = 0 ;
40410 PyObject *swig_obj[1] ;
40411
40412 if (!args) SWIG_fail;
40413 swig_obj[0] = args;
40414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40415 if (!SWIG_IsOK(res1)) {
40416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40417 }
40418 arg1 = reinterpret_cast< wxMenu * >(argp1);
40419 {
40420 PyThreadState* __tstate = wxPyBeginAllowThreads();
40421 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40422 wxPyEndAllowThreads(__tstate);
40423 if (PyErr_Occurred()) SWIG_fail;
40424 }
40425 {
40426 resultobj = wxPyMake_wxObject(result, 0);
40427 }
40428 return resultobj;
40429 fail:
40430 return NULL;
40431 }
40432
40433
40434 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40435 PyObject *resultobj = 0;
40436 wxMenu *arg1 = (wxMenu *) 0 ;
40437 wxWindow *arg2 = (wxWindow *) 0 ;
40438 void *argp1 = 0 ;
40439 int res1 = 0 ;
40440 void *argp2 = 0 ;
40441 int res2 = 0 ;
40442 PyObject * obj0 = 0 ;
40443 PyObject * obj1 = 0 ;
40444 char * kwnames[] = {
40445 (char *) "self",(char *) "win", NULL
40446 };
40447
40448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40450 if (!SWIG_IsOK(res1)) {
40451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40452 }
40453 arg1 = reinterpret_cast< wxMenu * >(argp1);
40454 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40455 if (!SWIG_IsOK(res2)) {
40456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40457 }
40458 arg2 = reinterpret_cast< wxWindow * >(argp2);
40459 {
40460 PyThreadState* __tstate = wxPyBeginAllowThreads();
40461 (arg1)->SetInvokingWindow(arg2);
40462 wxPyEndAllowThreads(__tstate);
40463 if (PyErr_Occurred()) SWIG_fail;
40464 }
40465 resultobj = SWIG_Py_Void();
40466 return resultobj;
40467 fail:
40468 return NULL;
40469 }
40470
40471
40472 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40473 PyObject *resultobj = 0;
40474 wxMenu *arg1 = (wxMenu *) 0 ;
40475 wxWindow *result = 0 ;
40476 void *argp1 = 0 ;
40477 int res1 = 0 ;
40478 PyObject *swig_obj[1] ;
40479
40480 if (!args) SWIG_fail;
40481 swig_obj[0] = args;
40482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40483 if (!SWIG_IsOK(res1)) {
40484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40485 }
40486 arg1 = reinterpret_cast< wxMenu * >(argp1);
40487 {
40488 PyThreadState* __tstate = wxPyBeginAllowThreads();
40489 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40490 wxPyEndAllowThreads(__tstate);
40491 if (PyErr_Occurred()) SWIG_fail;
40492 }
40493 {
40494 resultobj = wxPyMake_wxObject(result, 0);
40495 }
40496 return resultobj;
40497 fail:
40498 return NULL;
40499 }
40500
40501
40502 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40503 PyObject *resultobj = 0;
40504 wxMenu *arg1 = (wxMenu *) 0 ;
40505 long result;
40506 void *argp1 = 0 ;
40507 int res1 = 0 ;
40508 PyObject *swig_obj[1] ;
40509
40510 if (!args) SWIG_fail;
40511 swig_obj[0] = args;
40512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40513 if (!SWIG_IsOK(res1)) {
40514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40515 }
40516 arg1 = reinterpret_cast< wxMenu * >(argp1);
40517 {
40518 PyThreadState* __tstate = wxPyBeginAllowThreads();
40519 result = (long)((wxMenu const *)arg1)->GetStyle();
40520 wxPyEndAllowThreads(__tstate);
40521 if (PyErr_Occurred()) SWIG_fail;
40522 }
40523 resultobj = SWIG_From_long(static_cast< long >(result));
40524 return resultobj;
40525 fail:
40526 return NULL;
40527 }
40528
40529
40530 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40531 PyObject *resultobj = 0;
40532 wxMenu *arg1 = (wxMenu *) 0 ;
40533 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40534 void *argp1 = 0 ;
40535 int res1 = 0 ;
40536 void *argp2 = 0 ;
40537 int res2 = 0 ;
40538 PyObject * obj0 = 0 ;
40539 PyObject * obj1 = 0 ;
40540 char * kwnames[] = {
40541 (char *) "self",(char *) "source", NULL
40542 };
40543
40544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40546 if (!SWIG_IsOK(res1)) {
40547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40548 }
40549 arg1 = reinterpret_cast< wxMenu * >(argp1);
40550 if (obj1) {
40551 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40552 if (!SWIG_IsOK(res2)) {
40553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40554 }
40555 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40556 }
40557 {
40558 PyThreadState* __tstate = wxPyBeginAllowThreads();
40559 (arg1)->UpdateUI(arg2);
40560 wxPyEndAllowThreads(__tstate);
40561 if (PyErr_Occurred()) SWIG_fail;
40562 }
40563 resultobj = SWIG_Py_Void();
40564 return resultobj;
40565 fail:
40566 return NULL;
40567 }
40568
40569
40570 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40571 PyObject *resultobj = 0;
40572 wxMenu *arg1 = (wxMenu *) 0 ;
40573 wxMenuBar *result = 0 ;
40574 void *argp1 = 0 ;
40575 int res1 = 0 ;
40576 PyObject *swig_obj[1] ;
40577
40578 if (!args) SWIG_fail;
40579 swig_obj[0] = args;
40580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40581 if (!SWIG_IsOK(res1)) {
40582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40583 }
40584 arg1 = reinterpret_cast< wxMenu * >(argp1);
40585 {
40586 PyThreadState* __tstate = wxPyBeginAllowThreads();
40587 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40588 wxPyEndAllowThreads(__tstate);
40589 if (PyErr_Occurred()) SWIG_fail;
40590 }
40591 {
40592 resultobj = wxPyMake_wxObject(result, (bool)0);
40593 }
40594 return resultobj;
40595 fail:
40596 return NULL;
40597 }
40598
40599
40600 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40601 PyObject *resultobj = 0;
40602 wxMenu *arg1 = (wxMenu *) 0 ;
40603 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40604 void *argp1 = 0 ;
40605 int res1 = 0 ;
40606 void *argp2 = 0 ;
40607 int res2 = 0 ;
40608 PyObject * obj0 = 0 ;
40609 PyObject * obj1 = 0 ;
40610 char * kwnames[] = {
40611 (char *) "self",(char *) "menubar", NULL
40612 };
40613
40614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40616 if (!SWIG_IsOK(res1)) {
40617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40618 }
40619 arg1 = reinterpret_cast< wxMenu * >(argp1);
40620 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40621 if (!SWIG_IsOK(res2)) {
40622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40623 }
40624 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40625 {
40626 PyThreadState* __tstate = wxPyBeginAllowThreads();
40627 (arg1)->Attach(arg2);
40628 wxPyEndAllowThreads(__tstate);
40629 if (PyErr_Occurred()) SWIG_fail;
40630 }
40631 resultobj = SWIG_Py_Void();
40632 return resultobj;
40633 fail:
40634 return NULL;
40635 }
40636
40637
40638 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40639 PyObject *resultobj = 0;
40640 wxMenu *arg1 = (wxMenu *) 0 ;
40641 void *argp1 = 0 ;
40642 int res1 = 0 ;
40643 PyObject *swig_obj[1] ;
40644
40645 if (!args) SWIG_fail;
40646 swig_obj[0] = args;
40647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40648 if (!SWIG_IsOK(res1)) {
40649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40650 }
40651 arg1 = reinterpret_cast< wxMenu * >(argp1);
40652 {
40653 PyThreadState* __tstate = wxPyBeginAllowThreads();
40654 (arg1)->Detach();
40655 wxPyEndAllowThreads(__tstate);
40656 if (PyErr_Occurred()) SWIG_fail;
40657 }
40658 resultobj = SWIG_Py_Void();
40659 return resultobj;
40660 fail:
40661 return NULL;
40662 }
40663
40664
40665 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40666 PyObject *resultobj = 0;
40667 wxMenu *arg1 = (wxMenu *) 0 ;
40668 bool result;
40669 void *argp1 = 0 ;
40670 int res1 = 0 ;
40671 PyObject *swig_obj[1] ;
40672
40673 if (!args) SWIG_fail;
40674 swig_obj[0] = args;
40675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40676 if (!SWIG_IsOK(res1)) {
40677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40678 }
40679 arg1 = reinterpret_cast< wxMenu * >(argp1);
40680 {
40681 PyThreadState* __tstate = wxPyBeginAllowThreads();
40682 result = (bool)((wxMenu const *)arg1)->IsAttached();
40683 wxPyEndAllowThreads(__tstate);
40684 if (PyErr_Occurred()) SWIG_fail;
40685 }
40686 {
40687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40688 }
40689 return resultobj;
40690 fail:
40691 return NULL;
40692 }
40693
40694
40695 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40696 PyObject *resultobj = 0;
40697 wxMenu *arg1 = (wxMenu *) 0 ;
40698 wxMenu *arg2 = (wxMenu *) 0 ;
40699 void *argp1 = 0 ;
40700 int res1 = 0 ;
40701 void *argp2 = 0 ;
40702 int res2 = 0 ;
40703 PyObject * obj0 = 0 ;
40704 PyObject * obj1 = 0 ;
40705 char * kwnames[] = {
40706 (char *) "self",(char *) "parent", NULL
40707 };
40708
40709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40711 if (!SWIG_IsOK(res1)) {
40712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40713 }
40714 arg1 = reinterpret_cast< wxMenu * >(argp1);
40715 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40716 if (!SWIG_IsOK(res2)) {
40717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40718 }
40719 arg2 = reinterpret_cast< wxMenu * >(argp2);
40720 {
40721 PyThreadState* __tstate = wxPyBeginAllowThreads();
40722 (arg1)->SetParent(arg2);
40723 wxPyEndAllowThreads(__tstate);
40724 if (PyErr_Occurred()) SWIG_fail;
40725 }
40726 resultobj = SWIG_Py_Void();
40727 return resultobj;
40728 fail:
40729 return NULL;
40730 }
40731
40732
40733 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40734 PyObject *resultobj = 0;
40735 wxMenu *arg1 = (wxMenu *) 0 ;
40736 wxMenu *result = 0 ;
40737 void *argp1 = 0 ;
40738 int res1 = 0 ;
40739 PyObject *swig_obj[1] ;
40740
40741 if (!args) SWIG_fail;
40742 swig_obj[0] = args;
40743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40744 if (!SWIG_IsOK(res1)) {
40745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40746 }
40747 arg1 = reinterpret_cast< wxMenu * >(argp1);
40748 {
40749 PyThreadState* __tstate = wxPyBeginAllowThreads();
40750 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40751 wxPyEndAllowThreads(__tstate);
40752 if (PyErr_Occurred()) SWIG_fail;
40753 }
40754 {
40755 resultobj = wxPyMake_wxObject(result, 0);
40756 }
40757 return resultobj;
40758 fail:
40759 return NULL;
40760 }
40761
40762
40763 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40764 PyObject *obj;
40765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40766 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40767 return SWIG_Py_Void();
40768 }
40769
40770 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40771 return SWIG_Python_InitShadowInstance(args);
40772 }
40773
40774 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40775 PyObject *resultobj = 0;
40776 long arg1 = (long) 0 ;
40777 wxMenuBar *result = 0 ;
40778 long val1 ;
40779 int ecode1 = 0 ;
40780 PyObject * obj0 = 0 ;
40781 char * kwnames[] = {
40782 (char *) "style", NULL
40783 };
40784
40785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40786 if (obj0) {
40787 ecode1 = SWIG_AsVal_long(obj0, &val1);
40788 if (!SWIG_IsOK(ecode1)) {
40789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40790 }
40791 arg1 = static_cast< long >(val1);
40792 }
40793 {
40794 if (!wxPyCheckForApp()) SWIG_fail;
40795 PyThreadState* __tstate = wxPyBeginAllowThreads();
40796 result = (wxMenuBar *)new wxMenuBar(arg1);
40797 wxPyEndAllowThreads(__tstate);
40798 if (PyErr_Occurred()) SWIG_fail;
40799 }
40800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40801 return resultobj;
40802 fail:
40803 return NULL;
40804 }
40805
40806
40807 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40808 PyObject *resultobj = 0;
40809 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40810 wxMenu *arg2 = (wxMenu *) 0 ;
40811 wxString *arg3 = 0 ;
40812 bool result;
40813 void *argp1 = 0 ;
40814 int res1 = 0 ;
40815 void *argp2 = 0 ;
40816 int res2 = 0 ;
40817 bool temp3 = false ;
40818 PyObject * obj0 = 0 ;
40819 PyObject * obj1 = 0 ;
40820 PyObject * obj2 = 0 ;
40821 char * kwnames[] = {
40822 (char *) "self",(char *) "menu",(char *) "title", NULL
40823 };
40824
40825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40827 if (!SWIG_IsOK(res1)) {
40828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40829 }
40830 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40831 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40832 if (!SWIG_IsOK(res2)) {
40833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40834 }
40835 arg2 = reinterpret_cast< wxMenu * >(argp2);
40836 {
40837 arg3 = wxString_in_helper(obj2);
40838 if (arg3 == NULL) SWIG_fail;
40839 temp3 = true;
40840 }
40841 {
40842 PyThreadState* __tstate = wxPyBeginAllowThreads();
40843 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40844 wxPyEndAllowThreads(__tstate);
40845 if (PyErr_Occurred()) SWIG_fail;
40846 }
40847 {
40848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40849 }
40850 {
40851 if (temp3)
40852 delete arg3;
40853 }
40854 return resultobj;
40855 fail:
40856 {
40857 if (temp3)
40858 delete arg3;
40859 }
40860 return NULL;
40861 }
40862
40863
40864 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40865 PyObject *resultobj = 0;
40866 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40867 size_t arg2 ;
40868 wxMenu *arg3 = (wxMenu *) 0 ;
40869 wxString *arg4 = 0 ;
40870 bool result;
40871 void *argp1 = 0 ;
40872 int res1 = 0 ;
40873 size_t val2 ;
40874 int ecode2 = 0 ;
40875 void *argp3 = 0 ;
40876 int res3 = 0 ;
40877 bool temp4 = false ;
40878 PyObject * obj0 = 0 ;
40879 PyObject * obj1 = 0 ;
40880 PyObject * obj2 = 0 ;
40881 PyObject * obj3 = 0 ;
40882 char * kwnames[] = {
40883 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40884 };
40885
40886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40888 if (!SWIG_IsOK(res1)) {
40889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40890 }
40891 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40892 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40893 if (!SWIG_IsOK(ecode2)) {
40894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40895 }
40896 arg2 = static_cast< size_t >(val2);
40897 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40898 if (!SWIG_IsOK(res3)) {
40899 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40900 }
40901 arg3 = reinterpret_cast< wxMenu * >(argp3);
40902 {
40903 arg4 = wxString_in_helper(obj3);
40904 if (arg4 == NULL) SWIG_fail;
40905 temp4 = true;
40906 }
40907 {
40908 PyThreadState* __tstate = wxPyBeginAllowThreads();
40909 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40910 wxPyEndAllowThreads(__tstate);
40911 if (PyErr_Occurred()) SWIG_fail;
40912 }
40913 {
40914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40915 }
40916 {
40917 if (temp4)
40918 delete arg4;
40919 }
40920 return resultobj;
40921 fail:
40922 {
40923 if (temp4)
40924 delete arg4;
40925 }
40926 return NULL;
40927 }
40928
40929
40930 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40931 PyObject *resultobj = 0;
40932 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40933 size_t result;
40934 void *argp1 = 0 ;
40935 int res1 = 0 ;
40936 PyObject *swig_obj[1] ;
40937
40938 if (!args) SWIG_fail;
40939 swig_obj[0] = args;
40940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40941 if (!SWIG_IsOK(res1)) {
40942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40943 }
40944 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40945 {
40946 PyThreadState* __tstate = wxPyBeginAllowThreads();
40947 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40948 wxPyEndAllowThreads(__tstate);
40949 if (PyErr_Occurred()) SWIG_fail;
40950 }
40951 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40952 return resultobj;
40953 fail:
40954 return NULL;
40955 }
40956
40957
40958 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40959 PyObject *resultobj = 0;
40960 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40961 size_t arg2 ;
40962 wxMenu *result = 0 ;
40963 void *argp1 = 0 ;
40964 int res1 = 0 ;
40965 size_t val2 ;
40966 int ecode2 = 0 ;
40967 PyObject * obj0 = 0 ;
40968 PyObject * obj1 = 0 ;
40969 char * kwnames[] = {
40970 (char *) "self",(char *) "pos", NULL
40971 };
40972
40973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40975 if (!SWIG_IsOK(res1)) {
40976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40977 }
40978 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40979 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40980 if (!SWIG_IsOK(ecode2)) {
40981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40982 }
40983 arg2 = static_cast< size_t >(val2);
40984 {
40985 PyThreadState* __tstate = wxPyBeginAllowThreads();
40986 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40987 wxPyEndAllowThreads(__tstate);
40988 if (PyErr_Occurred()) SWIG_fail;
40989 }
40990 {
40991 resultobj = wxPyMake_wxObject(result, 0);
40992 }
40993 return resultobj;
40994 fail:
40995 return NULL;
40996 }
40997
40998
40999 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41000 PyObject *resultobj = 0;
41001 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41002 size_t arg2 ;
41003 wxMenu *arg3 = (wxMenu *) 0 ;
41004 wxString *arg4 = 0 ;
41005 wxMenu *result = 0 ;
41006 void *argp1 = 0 ;
41007 int res1 = 0 ;
41008 size_t val2 ;
41009 int ecode2 = 0 ;
41010 void *argp3 = 0 ;
41011 int res3 = 0 ;
41012 bool temp4 = false ;
41013 PyObject * obj0 = 0 ;
41014 PyObject * obj1 = 0 ;
41015 PyObject * obj2 = 0 ;
41016 PyObject * obj3 = 0 ;
41017 char * kwnames[] = {
41018 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41019 };
41020
41021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41023 if (!SWIG_IsOK(res1)) {
41024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41025 }
41026 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41027 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41028 if (!SWIG_IsOK(ecode2)) {
41029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41030 }
41031 arg2 = static_cast< size_t >(val2);
41032 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41033 if (!SWIG_IsOK(res3)) {
41034 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41035 }
41036 arg3 = reinterpret_cast< wxMenu * >(argp3);
41037 {
41038 arg4 = wxString_in_helper(obj3);
41039 if (arg4 == NULL) SWIG_fail;
41040 temp4 = true;
41041 }
41042 {
41043 PyThreadState* __tstate = wxPyBeginAllowThreads();
41044 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41045 wxPyEndAllowThreads(__tstate);
41046 if (PyErr_Occurred()) SWIG_fail;
41047 }
41048 {
41049 resultobj = wxPyMake_wxObject(result, 0);
41050 }
41051 {
41052 if (temp4)
41053 delete arg4;
41054 }
41055 return resultobj;
41056 fail:
41057 {
41058 if (temp4)
41059 delete arg4;
41060 }
41061 return NULL;
41062 }
41063
41064
41065 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41066 PyObject *resultobj = 0;
41067 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41068 size_t arg2 ;
41069 wxMenu *result = 0 ;
41070 void *argp1 = 0 ;
41071 int res1 = 0 ;
41072 size_t val2 ;
41073 int ecode2 = 0 ;
41074 PyObject * obj0 = 0 ;
41075 PyObject * obj1 = 0 ;
41076 char * kwnames[] = {
41077 (char *) "self",(char *) "pos", NULL
41078 };
41079
41080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41082 if (!SWIG_IsOK(res1)) {
41083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41084 }
41085 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41086 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41087 if (!SWIG_IsOK(ecode2)) {
41088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41089 }
41090 arg2 = static_cast< size_t >(val2);
41091 {
41092 PyThreadState* __tstate = wxPyBeginAllowThreads();
41093 result = (wxMenu *)(arg1)->Remove(arg2);
41094 wxPyEndAllowThreads(__tstate);
41095 if (PyErr_Occurred()) SWIG_fail;
41096 }
41097 {
41098 resultobj = wxPyMake_wxObject(result, 0);
41099 }
41100 return resultobj;
41101 fail:
41102 return NULL;
41103 }
41104
41105
41106 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41107 PyObject *resultobj = 0;
41108 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41109 size_t arg2 ;
41110 bool arg3 ;
41111 void *argp1 = 0 ;
41112 int res1 = 0 ;
41113 size_t val2 ;
41114 int ecode2 = 0 ;
41115 bool val3 ;
41116 int ecode3 = 0 ;
41117 PyObject * obj0 = 0 ;
41118 PyObject * obj1 = 0 ;
41119 PyObject * obj2 = 0 ;
41120 char * kwnames[] = {
41121 (char *) "self",(char *) "pos",(char *) "enable", NULL
41122 };
41123
41124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41126 if (!SWIG_IsOK(res1)) {
41127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41128 }
41129 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41130 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41131 if (!SWIG_IsOK(ecode2)) {
41132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41133 }
41134 arg2 = static_cast< size_t >(val2);
41135 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41136 if (!SWIG_IsOK(ecode3)) {
41137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41138 }
41139 arg3 = static_cast< bool >(val3);
41140 {
41141 PyThreadState* __tstate = wxPyBeginAllowThreads();
41142 (arg1)->EnableTop(arg2,arg3);
41143 wxPyEndAllowThreads(__tstate);
41144 if (PyErr_Occurred()) SWIG_fail;
41145 }
41146 resultobj = SWIG_Py_Void();
41147 return resultobj;
41148 fail:
41149 return NULL;
41150 }
41151
41152
41153 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41154 PyObject *resultobj = 0;
41155 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41156 size_t arg2 ;
41157 bool result;
41158 void *argp1 = 0 ;
41159 int res1 = 0 ;
41160 size_t val2 ;
41161 int ecode2 = 0 ;
41162 PyObject * obj0 = 0 ;
41163 PyObject * obj1 = 0 ;
41164 char * kwnames[] = {
41165 (char *) "self",(char *) "pos", NULL
41166 };
41167
41168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41170 if (!SWIG_IsOK(res1)) {
41171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41172 }
41173 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41174 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41175 if (!SWIG_IsOK(ecode2)) {
41176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41177 }
41178 arg2 = static_cast< size_t >(val2);
41179 {
41180 PyThreadState* __tstate = wxPyBeginAllowThreads();
41181 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41182 wxPyEndAllowThreads(__tstate);
41183 if (PyErr_Occurred()) SWIG_fail;
41184 }
41185 {
41186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41187 }
41188 return resultobj;
41189 fail:
41190 return NULL;
41191 }
41192
41193
41194 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41195 PyObject *resultobj = 0;
41196 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41197 size_t arg2 ;
41198 wxString *arg3 = 0 ;
41199 void *argp1 = 0 ;
41200 int res1 = 0 ;
41201 size_t val2 ;
41202 int ecode2 = 0 ;
41203 bool temp3 = false ;
41204 PyObject * obj0 = 0 ;
41205 PyObject * obj1 = 0 ;
41206 PyObject * obj2 = 0 ;
41207 char * kwnames[] = {
41208 (char *) "self",(char *) "pos",(char *) "label", NULL
41209 };
41210
41211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41213 if (!SWIG_IsOK(res1)) {
41214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41215 }
41216 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41217 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41218 if (!SWIG_IsOK(ecode2)) {
41219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41220 }
41221 arg2 = static_cast< size_t >(val2);
41222 {
41223 arg3 = wxString_in_helper(obj2);
41224 if (arg3 == NULL) SWIG_fail;
41225 temp3 = true;
41226 }
41227 {
41228 PyThreadState* __tstate = wxPyBeginAllowThreads();
41229 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41230 wxPyEndAllowThreads(__tstate);
41231 if (PyErr_Occurred()) SWIG_fail;
41232 }
41233 resultobj = SWIG_Py_Void();
41234 {
41235 if (temp3)
41236 delete arg3;
41237 }
41238 return resultobj;
41239 fail:
41240 {
41241 if (temp3)
41242 delete arg3;
41243 }
41244 return NULL;
41245 }
41246
41247
41248 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41249 PyObject *resultobj = 0;
41250 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41251 size_t arg2 ;
41252 wxString result;
41253 void *argp1 = 0 ;
41254 int res1 = 0 ;
41255 size_t val2 ;
41256 int ecode2 = 0 ;
41257 PyObject * obj0 = 0 ;
41258 PyObject * obj1 = 0 ;
41259 char * kwnames[] = {
41260 (char *) "self",(char *) "pos", NULL
41261 };
41262
41263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41265 if (!SWIG_IsOK(res1)) {
41266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41267 }
41268 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41269 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41270 if (!SWIG_IsOK(ecode2)) {
41271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41272 }
41273 arg2 = static_cast< size_t >(val2);
41274 {
41275 PyThreadState* __tstate = wxPyBeginAllowThreads();
41276 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41277 wxPyEndAllowThreads(__tstate);
41278 if (PyErr_Occurred()) SWIG_fail;
41279 }
41280 {
41281 #if wxUSE_UNICODE
41282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41283 #else
41284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41285 #endif
41286 }
41287 return resultobj;
41288 fail:
41289 return NULL;
41290 }
41291
41292
41293 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41294 PyObject *resultobj = 0;
41295 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41296 wxString *arg2 = 0 ;
41297 wxString *arg3 = 0 ;
41298 int result;
41299 void *argp1 = 0 ;
41300 int res1 = 0 ;
41301 bool temp2 = false ;
41302 bool temp3 = false ;
41303 PyObject * obj0 = 0 ;
41304 PyObject * obj1 = 0 ;
41305 PyObject * obj2 = 0 ;
41306 char * kwnames[] = {
41307 (char *) "self",(char *) "menu",(char *) "item", NULL
41308 };
41309
41310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41312 if (!SWIG_IsOK(res1)) {
41313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41314 }
41315 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41316 {
41317 arg2 = wxString_in_helper(obj1);
41318 if (arg2 == NULL) SWIG_fail;
41319 temp2 = true;
41320 }
41321 {
41322 arg3 = wxString_in_helper(obj2);
41323 if (arg3 == NULL) SWIG_fail;
41324 temp3 = true;
41325 }
41326 {
41327 PyThreadState* __tstate = wxPyBeginAllowThreads();
41328 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41329 wxPyEndAllowThreads(__tstate);
41330 if (PyErr_Occurred()) SWIG_fail;
41331 }
41332 resultobj = SWIG_From_int(static_cast< int >(result));
41333 {
41334 if (temp2)
41335 delete arg2;
41336 }
41337 {
41338 if (temp3)
41339 delete arg3;
41340 }
41341 return resultobj;
41342 fail:
41343 {
41344 if (temp2)
41345 delete arg2;
41346 }
41347 {
41348 if (temp3)
41349 delete arg3;
41350 }
41351 return NULL;
41352 }
41353
41354
41355 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41356 PyObject *resultobj = 0;
41357 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41358 int arg2 ;
41359 wxMenuItem *result = 0 ;
41360 void *argp1 = 0 ;
41361 int res1 = 0 ;
41362 int val2 ;
41363 int ecode2 = 0 ;
41364 PyObject * obj0 = 0 ;
41365 PyObject * obj1 = 0 ;
41366 char * kwnames[] = {
41367 (char *) "self",(char *) "id", NULL
41368 };
41369
41370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41372 if (!SWIG_IsOK(res1)) {
41373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41374 }
41375 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41376 ecode2 = SWIG_AsVal_int(obj1, &val2);
41377 if (!SWIG_IsOK(ecode2)) {
41378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41379 }
41380 arg2 = static_cast< int >(val2);
41381 {
41382 PyThreadState* __tstate = wxPyBeginAllowThreads();
41383 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41384 wxPyEndAllowThreads(__tstate);
41385 if (PyErr_Occurred()) SWIG_fail;
41386 }
41387 {
41388 resultobj = wxPyMake_wxObject(result, (bool)0);
41389 }
41390 return resultobj;
41391 fail:
41392 return NULL;
41393 }
41394
41395
41396 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41397 PyObject *resultobj = 0;
41398 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41399 wxString *arg2 = 0 ;
41400 int result;
41401 void *argp1 = 0 ;
41402 int res1 = 0 ;
41403 bool temp2 = false ;
41404 PyObject * obj0 = 0 ;
41405 PyObject * obj1 = 0 ;
41406 char * kwnames[] = {
41407 (char *) "self",(char *) "title", NULL
41408 };
41409
41410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41412 if (!SWIG_IsOK(res1)) {
41413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41414 }
41415 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41416 {
41417 arg2 = wxString_in_helper(obj1);
41418 if (arg2 == NULL) SWIG_fail;
41419 temp2 = true;
41420 }
41421 {
41422 PyThreadState* __tstate = wxPyBeginAllowThreads();
41423 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41424 wxPyEndAllowThreads(__tstate);
41425 if (PyErr_Occurred()) SWIG_fail;
41426 }
41427 resultobj = SWIG_From_int(static_cast< int >(result));
41428 {
41429 if (temp2)
41430 delete arg2;
41431 }
41432 return resultobj;
41433 fail:
41434 {
41435 if (temp2)
41436 delete arg2;
41437 }
41438 return NULL;
41439 }
41440
41441
41442 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41443 PyObject *resultobj = 0;
41444 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41445 int arg2 ;
41446 bool arg3 ;
41447 void *argp1 = 0 ;
41448 int res1 = 0 ;
41449 int val2 ;
41450 int ecode2 = 0 ;
41451 bool val3 ;
41452 int ecode3 = 0 ;
41453 PyObject * obj0 = 0 ;
41454 PyObject * obj1 = 0 ;
41455 PyObject * obj2 = 0 ;
41456 char * kwnames[] = {
41457 (char *) "self",(char *) "id",(char *) "enable", NULL
41458 };
41459
41460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41462 if (!SWIG_IsOK(res1)) {
41463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41464 }
41465 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41466 ecode2 = SWIG_AsVal_int(obj1, &val2);
41467 if (!SWIG_IsOK(ecode2)) {
41468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41469 }
41470 arg2 = static_cast< int >(val2);
41471 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41472 if (!SWIG_IsOK(ecode3)) {
41473 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41474 }
41475 arg3 = static_cast< bool >(val3);
41476 {
41477 PyThreadState* __tstate = wxPyBeginAllowThreads();
41478 (arg1)->Enable(arg2,arg3);
41479 wxPyEndAllowThreads(__tstate);
41480 if (PyErr_Occurred()) SWIG_fail;
41481 }
41482 resultobj = SWIG_Py_Void();
41483 return resultobj;
41484 fail:
41485 return NULL;
41486 }
41487
41488
41489 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41490 PyObject *resultobj = 0;
41491 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41492 int arg2 ;
41493 bool arg3 ;
41494 void *argp1 = 0 ;
41495 int res1 = 0 ;
41496 int val2 ;
41497 int ecode2 = 0 ;
41498 bool val3 ;
41499 int ecode3 = 0 ;
41500 PyObject * obj0 = 0 ;
41501 PyObject * obj1 = 0 ;
41502 PyObject * obj2 = 0 ;
41503 char * kwnames[] = {
41504 (char *) "self",(char *) "id",(char *) "check", NULL
41505 };
41506
41507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41509 if (!SWIG_IsOK(res1)) {
41510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41511 }
41512 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41513 ecode2 = SWIG_AsVal_int(obj1, &val2);
41514 if (!SWIG_IsOK(ecode2)) {
41515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41516 }
41517 arg2 = static_cast< int >(val2);
41518 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41519 if (!SWIG_IsOK(ecode3)) {
41520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41521 }
41522 arg3 = static_cast< bool >(val3);
41523 {
41524 PyThreadState* __tstate = wxPyBeginAllowThreads();
41525 (arg1)->Check(arg2,arg3);
41526 wxPyEndAllowThreads(__tstate);
41527 if (PyErr_Occurred()) SWIG_fail;
41528 }
41529 resultobj = SWIG_Py_Void();
41530 return resultobj;
41531 fail:
41532 return NULL;
41533 }
41534
41535
41536 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41537 PyObject *resultobj = 0;
41538 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41539 int arg2 ;
41540 bool result;
41541 void *argp1 = 0 ;
41542 int res1 = 0 ;
41543 int val2 ;
41544 int ecode2 = 0 ;
41545 PyObject * obj0 = 0 ;
41546 PyObject * obj1 = 0 ;
41547 char * kwnames[] = {
41548 (char *) "self",(char *) "id", NULL
41549 };
41550
41551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41553 if (!SWIG_IsOK(res1)) {
41554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41555 }
41556 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41557 ecode2 = SWIG_AsVal_int(obj1, &val2);
41558 if (!SWIG_IsOK(ecode2)) {
41559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41560 }
41561 arg2 = static_cast< int >(val2);
41562 {
41563 PyThreadState* __tstate = wxPyBeginAllowThreads();
41564 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41565 wxPyEndAllowThreads(__tstate);
41566 if (PyErr_Occurred()) SWIG_fail;
41567 }
41568 {
41569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41570 }
41571 return resultobj;
41572 fail:
41573 return NULL;
41574 }
41575
41576
41577 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41578 PyObject *resultobj = 0;
41579 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41580 int arg2 ;
41581 bool result;
41582 void *argp1 = 0 ;
41583 int res1 = 0 ;
41584 int val2 ;
41585 int ecode2 = 0 ;
41586 PyObject * obj0 = 0 ;
41587 PyObject * obj1 = 0 ;
41588 char * kwnames[] = {
41589 (char *) "self",(char *) "id", NULL
41590 };
41591
41592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41594 if (!SWIG_IsOK(res1)) {
41595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41596 }
41597 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41598 ecode2 = SWIG_AsVal_int(obj1, &val2);
41599 if (!SWIG_IsOK(ecode2)) {
41600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41601 }
41602 arg2 = static_cast< int >(val2);
41603 {
41604 PyThreadState* __tstate = wxPyBeginAllowThreads();
41605 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41606 wxPyEndAllowThreads(__tstate);
41607 if (PyErr_Occurred()) SWIG_fail;
41608 }
41609 {
41610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41611 }
41612 return resultobj;
41613 fail:
41614 return NULL;
41615 }
41616
41617
41618 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41619 PyObject *resultobj = 0;
41620 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41621 int arg2 ;
41622 wxString *arg3 = 0 ;
41623 void *argp1 = 0 ;
41624 int res1 = 0 ;
41625 int val2 ;
41626 int ecode2 = 0 ;
41627 bool temp3 = false ;
41628 PyObject * obj0 = 0 ;
41629 PyObject * obj1 = 0 ;
41630 PyObject * obj2 = 0 ;
41631 char * kwnames[] = {
41632 (char *) "self",(char *) "id",(char *) "label", NULL
41633 };
41634
41635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41637 if (!SWIG_IsOK(res1)) {
41638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41639 }
41640 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41641 ecode2 = SWIG_AsVal_int(obj1, &val2);
41642 if (!SWIG_IsOK(ecode2)) {
41643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41644 }
41645 arg2 = static_cast< int >(val2);
41646 {
41647 arg3 = wxString_in_helper(obj2);
41648 if (arg3 == NULL) SWIG_fail;
41649 temp3 = true;
41650 }
41651 {
41652 PyThreadState* __tstate = wxPyBeginAllowThreads();
41653 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41654 wxPyEndAllowThreads(__tstate);
41655 if (PyErr_Occurred()) SWIG_fail;
41656 }
41657 resultobj = SWIG_Py_Void();
41658 {
41659 if (temp3)
41660 delete arg3;
41661 }
41662 return resultobj;
41663 fail:
41664 {
41665 if (temp3)
41666 delete arg3;
41667 }
41668 return NULL;
41669 }
41670
41671
41672 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41673 PyObject *resultobj = 0;
41674 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41675 int arg2 ;
41676 wxString result;
41677 void *argp1 = 0 ;
41678 int res1 = 0 ;
41679 int val2 ;
41680 int ecode2 = 0 ;
41681 PyObject * obj0 = 0 ;
41682 PyObject * obj1 = 0 ;
41683 char * kwnames[] = {
41684 (char *) "self",(char *) "id", NULL
41685 };
41686
41687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41689 if (!SWIG_IsOK(res1)) {
41690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41691 }
41692 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41693 ecode2 = SWIG_AsVal_int(obj1, &val2);
41694 if (!SWIG_IsOK(ecode2)) {
41695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41696 }
41697 arg2 = static_cast< int >(val2);
41698 {
41699 PyThreadState* __tstate = wxPyBeginAllowThreads();
41700 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41701 wxPyEndAllowThreads(__tstate);
41702 if (PyErr_Occurred()) SWIG_fail;
41703 }
41704 {
41705 #if wxUSE_UNICODE
41706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41707 #else
41708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41709 #endif
41710 }
41711 return resultobj;
41712 fail:
41713 return NULL;
41714 }
41715
41716
41717 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41718 PyObject *resultobj = 0;
41719 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41720 int arg2 ;
41721 wxString *arg3 = 0 ;
41722 void *argp1 = 0 ;
41723 int res1 = 0 ;
41724 int val2 ;
41725 int ecode2 = 0 ;
41726 bool temp3 = false ;
41727 PyObject * obj0 = 0 ;
41728 PyObject * obj1 = 0 ;
41729 PyObject * obj2 = 0 ;
41730 char * kwnames[] = {
41731 (char *) "self",(char *) "id",(char *) "helpString", NULL
41732 };
41733
41734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41736 if (!SWIG_IsOK(res1)) {
41737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41738 }
41739 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41740 ecode2 = SWIG_AsVal_int(obj1, &val2);
41741 if (!SWIG_IsOK(ecode2)) {
41742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41743 }
41744 arg2 = static_cast< int >(val2);
41745 {
41746 arg3 = wxString_in_helper(obj2);
41747 if (arg3 == NULL) SWIG_fail;
41748 temp3 = true;
41749 }
41750 {
41751 PyThreadState* __tstate = wxPyBeginAllowThreads();
41752 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41753 wxPyEndAllowThreads(__tstate);
41754 if (PyErr_Occurred()) SWIG_fail;
41755 }
41756 resultobj = SWIG_Py_Void();
41757 {
41758 if (temp3)
41759 delete arg3;
41760 }
41761 return resultobj;
41762 fail:
41763 {
41764 if (temp3)
41765 delete arg3;
41766 }
41767 return NULL;
41768 }
41769
41770
41771 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41772 PyObject *resultobj = 0;
41773 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41774 int arg2 ;
41775 wxString result;
41776 void *argp1 = 0 ;
41777 int res1 = 0 ;
41778 int val2 ;
41779 int ecode2 = 0 ;
41780 PyObject * obj0 = 0 ;
41781 PyObject * obj1 = 0 ;
41782 char * kwnames[] = {
41783 (char *) "self",(char *) "id", NULL
41784 };
41785
41786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41788 if (!SWIG_IsOK(res1)) {
41789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41790 }
41791 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41792 ecode2 = SWIG_AsVal_int(obj1, &val2);
41793 if (!SWIG_IsOK(ecode2)) {
41794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41795 }
41796 arg2 = static_cast< int >(val2);
41797 {
41798 PyThreadState* __tstate = wxPyBeginAllowThreads();
41799 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41800 wxPyEndAllowThreads(__tstate);
41801 if (PyErr_Occurred()) SWIG_fail;
41802 }
41803 {
41804 #if wxUSE_UNICODE
41805 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41806 #else
41807 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41808 #endif
41809 }
41810 return resultobj;
41811 fail:
41812 return NULL;
41813 }
41814
41815
41816 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41817 PyObject *resultobj = 0;
41818 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41819 wxFrame *result = 0 ;
41820 void *argp1 = 0 ;
41821 int res1 = 0 ;
41822 PyObject *swig_obj[1] ;
41823
41824 if (!args) SWIG_fail;
41825 swig_obj[0] = args;
41826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41827 if (!SWIG_IsOK(res1)) {
41828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41829 }
41830 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41831 {
41832 PyThreadState* __tstate = wxPyBeginAllowThreads();
41833 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41834 wxPyEndAllowThreads(__tstate);
41835 if (PyErr_Occurred()) SWIG_fail;
41836 }
41837 {
41838 resultobj = wxPyMake_wxObject(result, (bool)0);
41839 }
41840 return resultobj;
41841 fail:
41842 return NULL;
41843 }
41844
41845
41846 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41847 PyObject *resultobj = 0;
41848 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41849 bool result;
41850 void *argp1 = 0 ;
41851 int res1 = 0 ;
41852 PyObject *swig_obj[1] ;
41853
41854 if (!args) SWIG_fail;
41855 swig_obj[0] = args;
41856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41857 if (!SWIG_IsOK(res1)) {
41858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41859 }
41860 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41861 {
41862 PyThreadState* __tstate = wxPyBeginAllowThreads();
41863 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41864 wxPyEndAllowThreads(__tstate);
41865 if (PyErr_Occurred()) SWIG_fail;
41866 }
41867 {
41868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41869 }
41870 return resultobj;
41871 fail:
41872 return NULL;
41873 }
41874
41875
41876 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41877 PyObject *resultobj = 0;
41878 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41879 wxFrame *arg2 = (wxFrame *) 0 ;
41880 void *argp1 = 0 ;
41881 int res1 = 0 ;
41882 void *argp2 = 0 ;
41883 int res2 = 0 ;
41884 PyObject * obj0 = 0 ;
41885 PyObject * obj1 = 0 ;
41886 char * kwnames[] = {
41887 (char *) "self",(char *) "frame", NULL
41888 };
41889
41890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41892 if (!SWIG_IsOK(res1)) {
41893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41894 }
41895 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41896 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41897 if (!SWIG_IsOK(res2)) {
41898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41899 }
41900 arg2 = reinterpret_cast< wxFrame * >(argp2);
41901 {
41902 PyThreadState* __tstate = wxPyBeginAllowThreads();
41903 (arg1)->Attach(arg2);
41904 wxPyEndAllowThreads(__tstate);
41905 if (PyErr_Occurred()) SWIG_fail;
41906 }
41907 resultobj = SWIG_Py_Void();
41908 return resultobj;
41909 fail:
41910 return NULL;
41911 }
41912
41913
41914 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41915 PyObject *resultobj = 0;
41916 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41917 void *argp1 = 0 ;
41918 int res1 = 0 ;
41919 PyObject *swig_obj[1] ;
41920
41921 if (!args) SWIG_fail;
41922 swig_obj[0] = args;
41923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41924 if (!SWIG_IsOK(res1)) {
41925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41926 }
41927 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41928 {
41929 PyThreadState* __tstate = wxPyBeginAllowThreads();
41930 (arg1)->Detach();
41931 wxPyEndAllowThreads(__tstate);
41932 if (PyErr_Occurred()) SWIG_fail;
41933 }
41934 resultobj = SWIG_Py_Void();
41935 return resultobj;
41936 fail:
41937 return NULL;
41938 }
41939
41940
41941 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41942 PyObject *resultobj = 0;
41943 bool arg1 ;
41944 bool val1 ;
41945 int ecode1 = 0 ;
41946 PyObject * obj0 = 0 ;
41947 char * kwnames[] = {
41948 (char *) "enable", NULL
41949 };
41950
41951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41952 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41953 if (!SWIG_IsOK(ecode1)) {
41954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41955 }
41956 arg1 = static_cast< bool >(val1);
41957 {
41958 PyThreadState* __tstate = wxPyBeginAllowThreads();
41959 wxMenuBar_SetAutoWindowMenu(arg1);
41960 wxPyEndAllowThreads(__tstate);
41961 if (PyErr_Occurred()) SWIG_fail;
41962 }
41963 resultobj = SWIG_Py_Void();
41964 return resultobj;
41965 fail:
41966 return NULL;
41967 }
41968
41969
41970 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41971 PyObject *resultobj = 0;
41972 bool result;
41973
41974 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41975 {
41976 PyThreadState* __tstate = wxPyBeginAllowThreads();
41977 result = (bool)wxMenuBar_GetAutoWindowMenu();
41978 wxPyEndAllowThreads(__tstate);
41979 if (PyErr_Occurred()) SWIG_fail;
41980 }
41981 {
41982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41983 }
41984 return resultobj;
41985 fail:
41986 return NULL;
41987 }
41988
41989
41990 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41991 PyObject *obj;
41992 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41993 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41994 return SWIG_Py_Void();
41995 }
41996
41997 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41998 return SWIG_Python_InitShadowInstance(args);
41999 }
42000
42001 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42002 PyObject *resultobj = 0;
42003 wxMenu *arg1 = (wxMenu *) NULL ;
42004 int arg2 = (int) wxID_ANY ;
42005 wxString const &arg3_defvalue = wxPyEmptyString ;
42006 wxString *arg3 = (wxString *) &arg3_defvalue ;
42007 wxString const &arg4_defvalue = wxPyEmptyString ;
42008 wxString *arg4 = (wxString *) &arg4_defvalue ;
42009 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42010 wxMenu *arg6 = (wxMenu *) NULL ;
42011 wxMenuItem *result = 0 ;
42012 void *argp1 = 0 ;
42013 int res1 = 0 ;
42014 int val2 ;
42015 int ecode2 = 0 ;
42016 bool temp3 = false ;
42017 bool temp4 = false ;
42018 int val5 ;
42019 int ecode5 = 0 ;
42020 void *argp6 = 0 ;
42021 int res6 = 0 ;
42022 PyObject * obj0 = 0 ;
42023 PyObject * obj1 = 0 ;
42024 PyObject * obj2 = 0 ;
42025 PyObject * obj3 = 0 ;
42026 PyObject * obj4 = 0 ;
42027 PyObject * obj5 = 0 ;
42028 char * kwnames[] = {
42029 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42030 };
42031
42032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42033 if (obj0) {
42034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42035 if (!SWIG_IsOK(res1)) {
42036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42037 }
42038 arg1 = reinterpret_cast< wxMenu * >(argp1);
42039 }
42040 if (obj1) {
42041 ecode2 = SWIG_AsVal_int(obj1, &val2);
42042 if (!SWIG_IsOK(ecode2)) {
42043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42044 }
42045 arg2 = static_cast< int >(val2);
42046 }
42047 if (obj2) {
42048 {
42049 arg3 = wxString_in_helper(obj2);
42050 if (arg3 == NULL) SWIG_fail;
42051 temp3 = true;
42052 }
42053 }
42054 if (obj3) {
42055 {
42056 arg4 = wxString_in_helper(obj3);
42057 if (arg4 == NULL) SWIG_fail;
42058 temp4 = true;
42059 }
42060 }
42061 if (obj4) {
42062 ecode5 = SWIG_AsVal_int(obj4, &val5);
42063 if (!SWIG_IsOK(ecode5)) {
42064 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42065 }
42066 arg5 = static_cast< wxItemKind >(val5);
42067 }
42068 if (obj5) {
42069 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42070 if (!SWIG_IsOK(res6)) {
42071 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42072 }
42073 arg6 = reinterpret_cast< wxMenu * >(argp6);
42074 }
42075 {
42076 PyThreadState* __tstate = wxPyBeginAllowThreads();
42077 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42078 wxPyEndAllowThreads(__tstate);
42079 if (PyErr_Occurred()) SWIG_fail;
42080 }
42081 {
42082 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42083 }
42084 {
42085 if (temp3)
42086 delete arg3;
42087 }
42088 {
42089 if (temp4)
42090 delete arg4;
42091 }
42092 return resultobj;
42093 fail:
42094 {
42095 if (temp3)
42096 delete arg3;
42097 }
42098 {
42099 if (temp4)
42100 delete arg4;
42101 }
42102 return NULL;
42103 }
42104
42105
42106 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42107 PyObject *resultobj = 0;
42108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42109 void *argp1 = 0 ;
42110 int res1 = 0 ;
42111 PyObject *swig_obj[1] ;
42112
42113 if (!args) SWIG_fail;
42114 swig_obj[0] = args;
42115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42116 if (!SWIG_IsOK(res1)) {
42117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42118 }
42119 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42120 {
42121 PyThreadState* __tstate = wxPyBeginAllowThreads();
42122 delete arg1;
42123
42124 wxPyEndAllowThreads(__tstate);
42125 if (PyErr_Occurred()) SWIG_fail;
42126 }
42127 resultobj = SWIG_Py_Void();
42128 return resultobj;
42129 fail:
42130 return NULL;
42131 }
42132
42133
42134 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42135 PyObject *resultobj = 0;
42136 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42137 wxMenu *result = 0 ;
42138 void *argp1 = 0 ;
42139 int res1 = 0 ;
42140 PyObject *swig_obj[1] ;
42141
42142 if (!args) SWIG_fail;
42143 swig_obj[0] = args;
42144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42145 if (!SWIG_IsOK(res1)) {
42146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42147 }
42148 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42149 {
42150 PyThreadState* __tstate = wxPyBeginAllowThreads();
42151 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42152 wxPyEndAllowThreads(__tstate);
42153 if (PyErr_Occurred()) SWIG_fail;
42154 }
42155 {
42156 resultobj = wxPyMake_wxObject(result, 0);
42157 }
42158 return resultobj;
42159 fail:
42160 return NULL;
42161 }
42162
42163
42164 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42165 PyObject *resultobj = 0;
42166 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42167 wxMenu *arg2 = (wxMenu *) 0 ;
42168 void *argp1 = 0 ;
42169 int res1 = 0 ;
42170 void *argp2 = 0 ;
42171 int res2 = 0 ;
42172 PyObject * obj0 = 0 ;
42173 PyObject * obj1 = 0 ;
42174 char * kwnames[] = {
42175 (char *) "self",(char *) "menu", NULL
42176 };
42177
42178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42180 if (!SWIG_IsOK(res1)) {
42181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42182 }
42183 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42185 if (!SWIG_IsOK(res2)) {
42186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42187 }
42188 arg2 = reinterpret_cast< wxMenu * >(argp2);
42189 {
42190 PyThreadState* __tstate = wxPyBeginAllowThreads();
42191 (arg1)->SetMenu(arg2);
42192 wxPyEndAllowThreads(__tstate);
42193 if (PyErr_Occurred()) SWIG_fail;
42194 }
42195 resultobj = SWIG_Py_Void();
42196 return resultobj;
42197 fail:
42198 return NULL;
42199 }
42200
42201
42202 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42203 PyObject *resultobj = 0;
42204 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42205 int arg2 ;
42206 void *argp1 = 0 ;
42207 int res1 = 0 ;
42208 int val2 ;
42209 int ecode2 = 0 ;
42210 PyObject * obj0 = 0 ;
42211 PyObject * obj1 = 0 ;
42212 char * kwnames[] = {
42213 (char *) "self",(char *) "id", NULL
42214 };
42215
42216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42218 if (!SWIG_IsOK(res1)) {
42219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42220 }
42221 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42222 ecode2 = SWIG_AsVal_int(obj1, &val2);
42223 if (!SWIG_IsOK(ecode2)) {
42224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42225 }
42226 arg2 = static_cast< int >(val2);
42227 {
42228 PyThreadState* __tstate = wxPyBeginAllowThreads();
42229 (arg1)->SetId(arg2);
42230 wxPyEndAllowThreads(__tstate);
42231 if (PyErr_Occurred()) SWIG_fail;
42232 }
42233 resultobj = SWIG_Py_Void();
42234 return resultobj;
42235 fail:
42236 return NULL;
42237 }
42238
42239
42240 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42241 PyObject *resultobj = 0;
42242 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42243 int result;
42244 void *argp1 = 0 ;
42245 int res1 = 0 ;
42246 PyObject *swig_obj[1] ;
42247
42248 if (!args) SWIG_fail;
42249 swig_obj[0] = args;
42250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42251 if (!SWIG_IsOK(res1)) {
42252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42253 }
42254 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42255 {
42256 PyThreadState* __tstate = wxPyBeginAllowThreads();
42257 result = (int)((wxMenuItem const *)arg1)->GetId();
42258 wxPyEndAllowThreads(__tstate);
42259 if (PyErr_Occurred()) SWIG_fail;
42260 }
42261 resultobj = SWIG_From_int(static_cast< int >(result));
42262 return resultobj;
42263 fail:
42264 return NULL;
42265 }
42266
42267
42268 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42269 PyObject *resultobj = 0;
42270 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42271 bool result;
42272 void *argp1 = 0 ;
42273 int res1 = 0 ;
42274 PyObject *swig_obj[1] ;
42275
42276 if (!args) SWIG_fail;
42277 swig_obj[0] = args;
42278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42279 if (!SWIG_IsOK(res1)) {
42280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42281 }
42282 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42283 {
42284 PyThreadState* __tstate = wxPyBeginAllowThreads();
42285 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42286 wxPyEndAllowThreads(__tstate);
42287 if (PyErr_Occurred()) SWIG_fail;
42288 }
42289 {
42290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42291 }
42292 return resultobj;
42293 fail:
42294 return NULL;
42295 }
42296
42297
42298 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42299 PyObject *resultobj = 0;
42300 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42301 wxString *arg2 = 0 ;
42302 void *argp1 = 0 ;
42303 int res1 = 0 ;
42304 bool temp2 = false ;
42305 PyObject * obj0 = 0 ;
42306 PyObject * obj1 = 0 ;
42307 char * kwnames[] = {
42308 (char *) "self",(char *) "str", NULL
42309 };
42310
42311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42313 if (!SWIG_IsOK(res1)) {
42314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42315 }
42316 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42317 {
42318 arg2 = wxString_in_helper(obj1);
42319 if (arg2 == NULL) SWIG_fail;
42320 temp2 = true;
42321 }
42322 {
42323 PyThreadState* __tstate = wxPyBeginAllowThreads();
42324 (arg1)->SetText((wxString const &)*arg2);
42325 wxPyEndAllowThreads(__tstate);
42326 if (PyErr_Occurred()) SWIG_fail;
42327 }
42328 resultobj = SWIG_Py_Void();
42329 {
42330 if (temp2)
42331 delete arg2;
42332 }
42333 return resultobj;
42334 fail:
42335 {
42336 if (temp2)
42337 delete arg2;
42338 }
42339 return NULL;
42340 }
42341
42342
42343 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42344 PyObject *resultobj = 0;
42345 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42346 wxString result;
42347 void *argp1 = 0 ;
42348 int res1 = 0 ;
42349 PyObject *swig_obj[1] ;
42350
42351 if (!args) SWIG_fail;
42352 swig_obj[0] = args;
42353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42354 if (!SWIG_IsOK(res1)) {
42355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42356 }
42357 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42358 {
42359 PyThreadState* __tstate = wxPyBeginAllowThreads();
42360 result = ((wxMenuItem const *)arg1)->GetLabel();
42361 wxPyEndAllowThreads(__tstate);
42362 if (PyErr_Occurred()) SWIG_fail;
42363 }
42364 {
42365 #if wxUSE_UNICODE
42366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42367 #else
42368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42369 #endif
42370 }
42371 return resultobj;
42372 fail:
42373 return NULL;
42374 }
42375
42376
42377 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42378 PyObject *resultobj = 0;
42379 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42380 wxString *result = 0 ;
42381 void *argp1 = 0 ;
42382 int res1 = 0 ;
42383 PyObject *swig_obj[1] ;
42384
42385 if (!args) SWIG_fail;
42386 swig_obj[0] = args;
42387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42388 if (!SWIG_IsOK(res1)) {
42389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42390 }
42391 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42392 {
42393 PyThreadState* __tstate = wxPyBeginAllowThreads();
42394 {
42395 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42396 result = (wxString *) &_result_ref;
42397 }
42398 wxPyEndAllowThreads(__tstate);
42399 if (PyErr_Occurred()) SWIG_fail;
42400 }
42401 {
42402 #if wxUSE_UNICODE
42403 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42404 #else
42405 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42406 #endif
42407 }
42408 return resultobj;
42409 fail:
42410 return NULL;
42411 }
42412
42413
42414 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42415 PyObject *resultobj = 0;
42416 wxString *arg1 = 0 ;
42417 wxString result;
42418 bool temp1 = false ;
42419 PyObject * obj0 = 0 ;
42420 char * kwnames[] = {
42421 (char *) "text", NULL
42422 };
42423
42424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42425 {
42426 arg1 = wxString_in_helper(obj0);
42427 if (arg1 == NULL) SWIG_fail;
42428 temp1 = true;
42429 }
42430 {
42431 PyThreadState* __tstate = wxPyBeginAllowThreads();
42432 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42433 wxPyEndAllowThreads(__tstate);
42434 if (PyErr_Occurred()) SWIG_fail;
42435 }
42436 {
42437 #if wxUSE_UNICODE
42438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42439 #else
42440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42441 #endif
42442 }
42443 {
42444 if (temp1)
42445 delete arg1;
42446 }
42447 return resultobj;
42448 fail:
42449 {
42450 if (temp1)
42451 delete arg1;
42452 }
42453 return NULL;
42454 }
42455
42456
42457 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42458 PyObject *resultobj = 0;
42459 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42460 wxItemKind result;
42461 void *argp1 = 0 ;
42462 int res1 = 0 ;
42463 PyObject *swig_obj[1] ;
42464
42465 if (!args) SWIG_fail;
42466 swig_obj[0] = args;
42467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42468 if (!SWIG_IsOK(res1)) {
42469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42470 }
42471 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42472 {
42473 PyThreadState* __tstate = wxPyBeginAllowThreads();
42474 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42475 wxPyEndAllowThreads(__tstate);
42476 if (PyErr_Occurred()) SWIG_fail;
42477 }
42478 resultobj = SWIG_From_int(static_cast< int >(result));
42479 return resultobj;
42480 fail:
42481 return NULL;
42482 }
42483
42484
42485 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42486 PyObject *resultobj = 0;
42487 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42488 wxItemKind arg2 ;
42489 void *argp1 = 0 ;
42490 int res1 = 0 ;
42491 int val2 ;
42492 int ecode2 = 0 ;
42493 PyObject * obj0 = 0 ;
42494 PyObject * obj1 = 0 ;
42495 char * kwnames[] = {
42496 (char *) "self",(char *) "kind", NULL
42497 };
42498
42499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42501 if (!SWIG_IsOK(res1)) {
42502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42503 }
42504 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42505 ecode2 = SWIG_AsVal_int(obj1, &val2);
42506 if (!SWIG_IsOK(ecode2)) {
42507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42508 }
42509 arg2 = static_cast< wxItemKind >(val2);
42510 {
42511 PyThreadState* __tstate = wxPyBeginAllowThreads();
42512 (arg1)->SetKind(arg2);
42513 wxPyEndAllowThreads(__tstate);
42514 if (PyErr_Occurred()) SWIG_fail;
42515 }
42516 resultobj = SWIG_Py_Void();
42517 return resultobj;
42518 fail:
42519 return NULL;
42520 }
42521
42522
42523 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42524 PyObject *resultobj = 0;
42525 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42526 bool arg2 ;
42527 void *argp1 = 0 ;
42528 int res1 = 0 ;
42529 bool val2 ;
42530 int ecode2 = 0 ;
42531 PyObject * obj0 = 0 ;
42532 PyObject * obj1 = 0 ;
42533 char * kwnames[] = {
42534 (char *) "self",(char *) "checkable", NULL
42535 };
42536
42537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42539 if (!SWIG_IsOK(res1)) {
42540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42541 }
42542 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42543 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42544 if (!SWIG_IsOK(ecode2)) {
42545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42546 }
42547 arg2 = static_cast< bool >(val2);
42548 {
42549 PyThreadState* __tstate = wxPyBeginAllowThreads();
42550 (arg1)->SetCheckable(arg2);
42551 wxPyEndAllowThreads(__tstate);
42552 if (PyErr_Occurred()) SWIG_fail;
42553 }
42554 resultobj = SWIG_Py_Void();
42555 return resultobj;
42556 fail:
42557 return NULL;
42558 }
42559
42560
42561 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42562 PyObject *resultobj = 0;
42563 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42564 bool result;
42565 void *argp1 = 0 ;
42566 int res1 = 0 ;
42567 PyObject *swig_obj[1] ;
42568
42569 if (!args) SWIG_fail;
42570 swig_obj[0] = args;
42571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42572 if (!SWIG_IsOK(res1)) {
42573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42574 }
42575 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42576 {
42577 PyThreadState* __tstate = wxPyBeginAllowThreads();
42578 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42579 wxPyEndAllowThreads(__tstate);
42580 if (PyErr_Occurred()) SWIG_fail;
42581 }
42582 {
42583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42584 }
42585 return resultobj;
42586 fail:
42587 return NULL;
42588 }
42589
42590
42591 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42592 PyObject *resultobj = 0;
42593 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42594 bool result;
42595 void *argp1 = 0 ;
42596 int res1 = 0 ;
42597 PyObject *swig_obj[1] ;
42598
42599 if (!args) SWIG_fail;
42600 swig_obj[0] = args;
42601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42602 if (!SWIG_IsOK(res1)) {
42603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42604 }
42605 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42606 {
42607 PyThreadState* __tstate = wxPyBeginAllowThreads();
42608 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42609 wxPyEndAllowThreads(__tstate);
42610 if (PyErr_Occurred()) SWIG_fail;
42611 }
42612 {
42613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42614 }
42615 return resultobj;
42616 fail:
42617 return NULL;
42618 }
42619
42620
42621 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42622 PyObject *resultobj = 0;
42623 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42624 wxMenu *arg2 = (wxMenu *) 0 ;
42625 void *argp1 = 0 ;
42626 int res1 = 0 ;
42627 void *argp2 = 0 ;
42628 int res2 = 0 ;
42629 PyObject * obj0 = 0 ;
42630 PyObject * obj1 = 0 ;
42631 char * kwnames[] = {
42632 (char *) "self",(char *) "menu", NULL
42633 };
42634
42635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42637 if (!SWIG_IsOK(res1)) {
42638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42639 }
42640 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42641 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42642 if (!SWIG_IsOK(res2)) {
42643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42644 }
42645 arg2 = reinterpret_cast< wxMenu * >(argp2);
42646 {
42647 PyThreadState* __tstate = wxPyBeginAllowThreads();
42648 (arg1)->SetSubMenu(arg2);
42649 wxPyEndAllowThreads(__tstate);
42650 if (PyErr_Occurred()) SWIG_fail;
42651 }
42652 resultobj = SWIG_Py_Void();
42653 return resultobj;
42654 fail:
42655 return NULL;
42656 }
42657
42658
42659 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42660 PyObject *resultobj = 0;
42661 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42662 wxMenu *result = 0 ;
42663 void *argp1 = 0 ;
42664 int res1 = 0 ;
42665 PyObject *swig_obj[1] ;
42666
42667 if (!args) SWIG_fail;
42668 swig_obj[0] = args;
42669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42670 if (!SWIG_IsOK(res1)) {
42671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42672 }
42673 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42674 {
42675 PyThreadState* __tstate = wxPyBeginAllowThreads();
42676 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42677 wxPyEndAllowThreads(__tstate);
42678 if (PyErr_Occurred()) SWIG_fail;
42679 }
42680 {
42681 resultobj = wxPyMake_wxObject(result, 0);
42682 }
42683 return resultobj;
42684 fail:
42685 return NULL;
42686 }
42687
42688
42689 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42690 PyObject *resultobj = 0;
42691 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42692 bool arg2 = (bool) true ;
42693 void *argp1 = 0 ;
42694 int res1 = 0 ;
42695 bool val2 ;
42696 int ecode2 = 0 ;
42697 PyObject * obj0 = 0 ;
42698 PyObject * obj1 = 0 ;
42699 char * kwnames[] = {
42700 (char *) "self",(char *) "enable", NULL
42701 };
42702
42703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42705 if (!SWIG_IsOK(res1)) {
42706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42707 }
42708 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42709 if (obj1) {
42710 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42711 if (!SWIG_IsOK(ecode2)) {
42712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42713 }
42714 arg2 = static_cast< bool >(val2);
42715 }
42716 {
42717 PyThreadState* __tstate = wxPyBeginAllowThreads();
42718 (arg1)->Enable(arg2);
42719 wxPyEndAllowThreads(__tstate);
42720 if (PyErr_Occurred()) SWIG_fail;
42721 }
42722 resultobj = SWIG_Py_Void();
42723 return resultobj;
42724 fail:
42725 return NULL;
42726 }
42727
42728
42729 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42730 PyObject *resultobj = 0;
42731 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42732 bool result;
42733 void *argp1 = 0 ;
42734 int res1 = 0 ;
42735 PyObject *swig_obj[1] ;
42736
42737 if (!args) SWIG_fail;
42738 swig_obj[0] = args;
42739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42740 if (!SWIG_IsOK(res1)) {
42741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42742 }
42743 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42744 {
42745 PyThreadState* __tstate = wxPyBeginAllowThreads();
42746 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42747 wxPyEndAllowThreads(__tstate);
42748 if (PyErr_Occurred()) SWIG_fail;
42749 }
42750 {
42751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42752 }
42753 return resultobj;
42754 fail:
42755 return NULL;
42756 }
42757
42758
42759 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42760 PyObject *resultobj = 0;
42761 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42762 bool arg2 = (bool) true ;
42763 void *argp1 = 0 ;
42764 int res1 = 0 ;
42765 bool val2 ;
42766 int ecode2 = 0 ;
42767 PyObject * obj0 = 0 ;
42768 PyObject * obj1 = 0 ;
42769 char * kwnames[] = {
42770 (char *) "self",(char *) "check", NULL
42771 };
42772
42773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42775 if (!SWIG_IsOK(res1)) {
42776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42777 }
42778 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42779 if (obj1) {
42780 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42781 if (!SWIG_IsOK(ecode2)) {
42782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42783 }
42784 arg2 = static_cast< bool >(val2);
42785 }
42786 {
42787 PyThreadState* __tstate = wxPyBeginAllowThreads();
42788 (arg1)->Check(arg2);
42789 wxPyEndAllowThreads(__tstate);
42790 if (PyErr_Occurred()) SWIG_fail;
42791 }
42792 resultobj = SWIG_Py_Void();
42793 return resultobj;
42794 fail:
42795 return NULL;
42796 }
42797
42798
42799 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42800 PyObject *resultobj = 0;
42801 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42802 bool result;
42803 void *argp1 = 0 ;
42804 int res1 = 0 ;
42805 PyObject *swig_obj[1] ;
42806
42807 if (!args) SWIG_fail;
42808 swig_obj[0] = args;
42809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42810 if (!SWIG_IsOK(res1)) {
42811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42812 }
42813 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42814 {
42815 PyThreadState* __tstate = wxPyBeginAllowThreads();
42816 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42817 wxPyEndAllowThreads(__tstate);
42818 if (PyErr_Occurred()) SWIG_fail;
42819 }
42820 {
42821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42822 }
42823 return resultobj;
42824 fail:
42825 return NULL;
42826 }
42827
42828
42829 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42830 PyObject *resultobj = 0;
42831 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42832 void *argp1 = 0 ;
42833 int res1 = 0 ;
42834 PyObject *swig_obj[1] ;
42835
42836 if (!args) SWIG_fail;
42837 swig_obj[0] = args;
42838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42839 if (!SWIG_IsOK(res1)) {
42840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42841 }
42842 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42843 {
42844 PyThreadState* __tstate = wxPyBeginAllowThreads();
42845 (arg1)->Toggle();
42846 wxPyEndAllowThreads(__tstate);
42847 if (PyErr_Occurred()) SWIG_fail;
42848 }
42849 resultobj = SWIG_Py_Void();
42850 return resultobj;
42851 fail:
42852 return NULL;
42853 }
42854
42855
42856 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42857 PyObject *resultobj = 0;
42858 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42859 wxString *arg2 = 0 ;
42860 void *argp1 = 0 ;
42861 int res1 = 0 ;
42862 bool temp2 = false ;
42863 PyObject * obj0 = 0 ;
42864 PyObject * obj1 = 0 ;
42865 char * kwnames[] = {
42866 (char *) "self",(char *) "str", NULL
42867 };
42868
42869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42871 if (!SWIG_IsOK(res1)) {
42872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42873 }
42874 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42875 {
42876 arg2 = wxString_in_helper(obj1);
42877 if (arg2 == NULL) SWIG_fail;
42878 temp2 = true;
42879 }
42880 {
42881 PyThreadState* __tstate = wxPyBeginAllowThreads();
42882 (arg1)->SetHelp((wxString const &)*arg2);
42883 wxPyEndAllowThreads(__tstate);
42884 if (PyErr_Occurred()) SWIG_fail;
42885 }
42886 resultobj = SWIG_Py_Void();
42887 {
42888 if (temp2)
42889 delete arg2;
42890 }
42891 return resultobj;
42892 fail:
42893 {
42894 if (temp2)
42895 delete arg2;
42896 }
42897 return NULL;
42898 }
42899
42900
42901 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42902 PyObject *resultobj = 0;
42903 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42904 wxString *result = 0 ;
42905 void *argp1 = 0 ;
42906 int res1 = 0 ;
42907 PyObject *swig_obj[1] ;
42908
42909 if (!args) SWIG_fail;
42910 swig_obj[0] = args;
42911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42912 if (!SWIG_IsOK(res1)) {
42913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42914 }
42915 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42916 {
42917 PyThreadState* __tstate = wxPyBeginAllowThreads();
42918 {
42919 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42920 result = (wxString *) &_result_ref;
42921 }
42922 wxPyEndAllowThreads(__tstate);
42923 if (PyErr_Occurred()) SWIG_fail;
42924 }
42925 {
42926 #if wxUSE_UNICODE
42927 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42928 #else
42929 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42930 #endif
42931 }
42932 return resultobj;
42933 fail:
42934 return NULL;
42935 }
42936
42937
42938 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42939 PyObject *resultobj = 0;
42940 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42941 wxAcceleratorEntry *result = 0 ;
42942 void *argp1 = 0 ;
42943 int res1 = 0 ;
42944 PyObject *swig_obj[1] ;
42945
42946 if (!args) SWIG_fail;
42947 swig_obj[0] = args;
42948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42949 if (!SWIG_IsOK(res1)) {
42950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42951 }
42952 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42953 {
42954 PyThreadState* __tstate = wxPyBeginAllowThreads();
42955 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42956 wxPyEndAllowThreads(__tstate);
42957 if (PyErr_Occurred()) SWIG_fail;
42958 }
42959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42960 return resultobj;
42961 fail:
42962 return NULL;
42963 }
42964
42965
42966 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42967 PyObject *resultobj = 0;
42968 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42969 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42970 void *argp1 = 0 ;
42971 int res1 = 0 ;
42972 void *argp2 = 0 ;
42973 int res2 = 0 ;
42974 PyObject * obj0 = 0 ;
42975 PyObject * obj1 = 0 ;
42976 char * kwnames[] = {
42977 (char *) "self",(char *) "accel", NULL
42978 };
42979
42980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42982 if (!SWIG_IsOK(res1)) {
42983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42984 }
42985 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42986 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42987 if (!SWIG_IsOK(res2)) {
42988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42989 }
42990 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42991 {
42992 PyThreadState* __tstate = wxPyBeginAllowThreads();
42993 (arg1)->SetAccel(arg2);
42994 wxPyEndAllowThreads(__tstate);
42995 if (PyErr_Occurred()) SWIG_fail;
42996 }
42997 resultobj = SWIG_Py_Void();
42998 return resultobj;
42999 fail:
43000 return NULL;
43001 }
43002
43003
43004 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43005 PyObject *resultobj = 0;
43006 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43007 wxBitmap *arg2 = 0 ;
43008 void *argp1 = 0 ;
43009 int res1 = 0 ;
43010 void *argp2 = 0 ;
43011 int res2 = 0 ;
43012 PyObject * obj0 = 0 ;
43013 PyObject * obj1 = 0 ;
43014 char * kwnames[] = {
43015 (char *) "self",(char *) "bitmap", NULL
43016 };
43017
43018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43020 if (!SWIG_IsOK(res1)) {
43021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43022 }
43023 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43024 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43025 if (!SWIG_IsOK(res2)) {
43026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43027 }
43028 if (!argp2) {
43029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43030 }
43031 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43032 {
43033 PyThreadState* __tstate = wxPyBeginAllowThreads();
43034 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43035 wxPyEndAllowThreads(__tstate);
43036 if (PyErr_Occurred()) SWIG_fail;
43037 }
43038 resultobj = SWIG_Py_Void();
43039 return resultobj;
43040 fail:
43041 return NULL;
43042 }
43043
43044
43045 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43046 PyObject *resultobj = 0;
43047 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43048 wxBitmap *result = 0 ;
43049 void *argp1 = 0 ;
43050 int res1 = 0 ;
43051 PyObject *swig_obj[1] ;
43052
43053 if (!args) SWIG_fail;
43054 swig_obj[0] = args;
43055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43056 if (!SWIG_IsOK(res1)) {
43057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43058 }
43059 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43060 {
43061 PyThreadState* __tstate = wxPyBeginAllowThreads();
43062 {
43063 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43064 result = (wxBitmap *) &_result_ref;
43065 }
43066 wxPyEndAllowThreads(__tstate);
43067 if (PyErr_Occurred()) SWIG_fail;
43068 }
43069 {
43070 wxBitmap* resultptr = new wxBitmap(*result);
43071 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43072 }
43073 return resultobj;
43074 fail:
43075 return NULL;
43076 }
43077
43078
43079 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43080 PyObject *resultobj = 0;
43081 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43082 wxFont *arg2 = 0 ;
43083 void *argp1 = 0 ;
43084 int res1 = 0 ;
43085 void *argp2 = 0 ;
43086 int res2 = 0 ;
43087 PyObject * obj0 = 0 ;
43088 PyObject * obj1 = 0 ;
43089 char * kwnames[] = {
43090 (char *) "self",(char *) "font", NULL
43091 };
43092
43093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43095 if (!SWIG_IsOK(res1)) {
43096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43097 }
43098 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43099 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43100 if (!SWIG_IsOK(res2)) {
43101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43102 }
43103 if (!argp2) {
43104 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43105 }
43106 arg2 = reinterpret_cast< wxFont * >(argp2);
43107 {
43108 PyThreadState* __tstate = wxPyBeginAllowThreads();
43109 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43110 wxPyEndAllowThreads(__tstate);
43111 if (PyErr_Occurred()) SWIG_fail;
43112 }
43113 resultobj = SWIG_Py_Void();
43114 return resultobj;
43115 fail:
43116 return NULL;
43117 }
43118
43119
43120 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43121 PyObject *resultobj = 0;
43122 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43123 wxFont result;
43124 void *argp1 = 0 ;
43125 int res1 = 0 ;
43126 PyObject *swig_obj[1] ;
43127
43128 if (!args) SWIG_fail;
43129 swig_obj[0] = args;
43130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43131 if (!SWIG_IsOK(res1)) {
43132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43133 }
43134 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43135 {
43136 PyThreadState* __tstate = wxPyBeginAllowThreads();
43137 result = wxMenuItem_GetFont(arg1);
43138 wxPyEndAllowThreads(__tstate);
43139 if (PyErr_Occurred()) SWIG_fail;
43140 }
43141 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43142 return resultobj;
43143 fail:
43144 return NULL;
43145 }
43146
43147
43148 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43149 PyObject *resultobj = 0;
43150 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43151 wxColour *arg2 = 0 ;
43152 void *argp1 = 0 ;
43153 int res1 = 0 ;
43154 wxColour temp2 ;
43155 PyObject * obj0 = 0 ;
43156 PyObject * obj1 = 0 ;
43157 char * kwnames[] = {
43158 (char *) "self",(char *) "colText", NULL
43159 };
43160
43161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43163 if (!SWIG_IsOK(res1)) {
43164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43165 }
43166 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43167 {
43168 arg2 = &temp2;
43169 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43170 }
43171 {
43172 PyThreadState* __tstate = wxPyBeginAllowThreads();
43173 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43174 wxPyEndAllowThreads(__tstate);
43175 if (PyErr_Occurred()) SWIG_fail;
43176 }
43177 resultobj = SWIG_Py_Void();
43178 return resultobj;
43179 fail:
43180 return NULL;
43181 }
43182
43183
43184 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43185 PyObject *resultobj = 0;
43186 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43187 wxColour result;
43188 void *argp1 = 0 ;
43189 int res1 = 0 ;
43190 PyObject *swig_obj[1] ;
43191
43192 if (!args) SWIG_fail;
43193 swig_obj[0] = args;
43194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43195 if (!SWIG_IsOK(res1)) {
43196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43197 }
43198 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43199 {
43200 PyThreadState* __tstate = wxPyBeginAllowThreads();
43201 result = wxMenuItem_GetTextColour(arg1);
43202 wxPyEndAllowThreads(__tstate);
43203 if (PyErr_Occurred()) SWIG_fail;
43204 }
43205 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43206 return resultobj;
43207 fail:
43208 return NULL;
43209 }
43210
43211
43212 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43213 PyObject *resultobj = 0;
43214 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43215 wxColour *arg2 = 0 ;
43216 void *argp1 = 0 ;
43217 int res1 = 0 ;
43218 wxColour temp2 ;
43219 PyObject * obj0 = 0 ;
43220 PyObject * obj1 = 0 ;
43221 char * kwnames[] = {
43222 (char *) "self",(char *) "colBack", NULL
43223 };
43224
43225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43227 if (!SWIG_IsOK(res1)) {
43228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43229 }
43230 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43231 {
43232 arg2 = &temp2;
43233 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43234 }
43235 {
43236 PyThreadState* __tstate = wxPyBeginAllowThreads();
43237 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43238 wxPyEndAllowThreads(__tstate);
43239 if (PyErr_Occurred()) SWIG_fail;
43240 }
43241 resultobj = SWIG_Py_Void();
43242 return resultobj;
43243 fail:
43244 return NULL;
43245 }
43246
43247
43248 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43249 PyObject *resultobj = 0;
43250 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43251 wxColour result;
43252 void *argp1 = 0 ;
43253 int res1 = 0 ;
43254 PyObject *swig_obj[1] ;
43255
43256 if (!args) SWIG_fail;
43257 swig_obj[0] = args;
43258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43259 if (!SWIG_IsOK(res1)) {
43260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43261 }
43262 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43263 {
43264 PyThreadState* __tstate = wxPyBeginAllowThreads();
43265 result = wxMenuItem_GetBackgroundColour(arg1);
43266 wxPyEndAllowThreads(__tstate);
43267 if (PyErr_Occurred()) SWIG_fail;
43268 }
43269 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43270 return resultobj;
43271 fail:
43272 return NULL;
43273 }
43274
43275
43276 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43277 PyObject *resultobj = 0;
43278 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43279 wxBitmap *arg2 = 0 ;
43280 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43281 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43282 void *argp1 = 0 ;
43283 int res1 = 0 ;
43284 void *argp2 = 0 ;
43285 int res2 = 0 ;
43286 void *argp3 = 0 ;
43287 int res3 = 0 ;
43288 PyObject * obj0 = 0 ;
43289 PyObject * obj1 = 0 ;
43290 PyObject * obj2 = 0 ;
43291 char * kwnames[] = {
43292 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43293 };
43294
43295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43297 if (!SWIG_IsOK(res1)) {
43298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43299 }
43300 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43301 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43302 if (!SWIG_IsOK(res2)) {
43303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43304 }
43305 if (!argp2) {
43306 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43307 }
43308 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43309 if (obj2) {
43310 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43311 if (!SWIG_IsOK(res3)) {
43312 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43313 }
43314 if (!argp3) {
43315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43316 }
43317 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43318 }
43319 {
43320 PyThreadState* __tstate = wxPyBeginAllowThreads();
43321 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43322 wxPyEndAllowThreads(__tstate);
43323 if (PyErr_Occurred()) SWIG_fail;
43324 }
43325 resultobj = SWIG_Py_Void();
43326 return resultobj;
43327 fail:
43328 return NULL;
43329 }
43330
43331
43332 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43333 PyObject *resultobj = 0;
43334 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43335 wxBitmap *arg2 = 0 ;
43336 void *argp1 = 0 ;
43337 int res1 = 0 ;
43338 void *argp2 = 0 ;
43339 int res2 = 0 ;
43340 PyObject * obj0 = 0 ;
43341 PyObject * obj1 = 0 ;
43342 char * kwnames[] = {
43343 (char *) "self",(char *) "bmpDisabled", NULL
43344 };
43345
43346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43348 if (!SWIG_IsOK(res1)) {
43349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43350 }
43351 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43352 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43353 if (!SWIG_IsOK(res2)) {
43354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43355 }
43356 if (!argp2) {
43357 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43358 }
43359 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43360 {
43361 PyThreadState* __tstate = wxPyBeginAllowThreads();
43362 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43363 wxPyEndAllowThreads(__tstate);
43364 if (PyErr_Occurred()) SWIG_fail;
43365 }
43366 resultobj = SWIG_Py_Void();
43367 return resultobj;
43368 fail:
43369 return NULL;
43370 }
43371
43372
43373 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43374 PyObject *resultobj = 0;
43375 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43376 wxBitmap *result = 0 ;
43377 void *argp1 = 0 ;
43378 int res1 = 0 ;
43379 PyObject *swig_obj[1] ;
43380
43381 if (!args) SWIG_fail;
43382 swig_obj[0] = args;
43383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43384 if (!SWIG_IsOK(res1)) {
43385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43386 }
43387 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43388 {
43389 PyThreadState* __tstate = wxPyBeginAllowThreads();
43390 {
43391 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43392 result = (wxBitmap *) &_result_ref;
43393 }
43394 wxPyEndAllowThreads(__tstate);
43395 if (PyErr_Occurred()) SWIG_fail;
43396 }
43397 {
43398 wxBitmap* resultptr = new wxBitmap(*result);
43399 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43400 }
43401 return resultobj;
43402 fail:
43403 return NULL;
43404 }
43405
43406
43407 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43408 PyObject *resultobj = 0;
43409 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43410 int arg2 ;
43411 void *argp1 = 0 ;
43412 int res1 = 0 ;
43413 int val2 ;
43414 int ecode2 = 0 ;
43415 PyObject * obj0 = 0 ;
43416 PyObject * obj1 = 0 ;
43417 char * kwnames[] = {
43418 (char *) "self",(char *) "nWidth", NULL
43419 };
43420
43421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43423 if (!SWIG_IsOK(res1)) {
43424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43425 }
43426 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43427 ecode2 = SWIG_AsVal_int(obj1, &val2);
43428 if (!SWIG_IsOK(ecode2)) {
43429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43430 }
43431 arg2 = static_cast< int >(val2);
43432 {
43433 PyThreadState* __tstate = wxPyBeginAllowThreads();
43434 wxMenuItem_SetMarginWidth(arg1,arg2);
43435 wxPyEndAllowThreads(__tstate);
43436 if (PyErr_Occurred()) SWIG_fail;
43437 }
43438 resultobj = SWIG_Py_Void();
43439 return resultobj;
43440 fail:
43441 return NULL;
43442 }
43443
43444
43445 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43446 PyObject *resultobj = 0;
43447 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43448 int result;
43449 void *argp1 = 0 ;
43450 int res1 = 0 ;
43451 PyObject *swig_obj[1] ;
43452
43453 if (!args) SWIG_fail;
43454 swig_obj[0] = args;
43455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43456 if (!SWIG_IsOK(res1)) {
43457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43458 }
43459 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43460 {
43461 PyThreadState* __tstate = wxPyBeginAllowThreads();
43462 result = (int)wxMenuItem_GetMarginWidth(arg1);
43463 wxPyEndAllowThreads(__tstate);
43464 if (PyErr_Occurred()) SWIG_fail;
43465 }
43466 resultobj = SWIG_From_int(static_cast< int >(result));
43467 return resultobj;
43468 fail:
43469 return NULL;
43470 }
43471
43472
43473 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43474 PyObject *resultobj = 0;
43475 int result;
43476
43477 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43478 {
43479 PyThreadState* __tstate = wxPyBeginAllowThreads();
43480 result = (int)wxMenuItem_GetDefaultMarginWidth();
43481 wxPyEndAllowThreads(__tstate);
43482 if (PyErr_Occurred()) SWIG_fail;
43483 }
43484 resultobj = SWIG_From_int(static_cast< int >(result));
43485 return resultobj;
43486 fail:
43487 return NULL;
43488 }
43489
43490
43491 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43492 PyObject *resultobj = 0;
43493 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43494 bool result;
43495 void *argp1 = 0 ;
43496 int res1 = 0 ;
43497 PyObject *swig_obj[1] ;
43498
43499 if (!args) SWIG_fail;
43500 swig_obj[0] = args;
43501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43502 if (!SWIG_IsOK(res1)) {
43503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43504 }
43505 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43506 {
43507 PyThreadState* __tstate = wxPyBeginAllowThreads();
43508 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43509 wxPyEndAllowThreads(__tstate);
43510 if (PyErr_Occurred()) SWIG_fail;
43511 }
43512 {
43513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43514 }
43515 return resultobj;
43516 fail:
43517 return NULL;
43518 }
43519
43520
43521 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43522 PyObject *resultobj = 0;
43523 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43524 bool arg2 = (bool) true ;
43525 void *argp1 = 0 ;
43526 int res1 = 0 ;
43527 bool val2 ;
43528 int ecode2 = 0 ;
43529 PyObject * obj0 = 0 ;
43530 PyObject * obj1 = 0 ;
43531 char * kwnames[] = {
43532 (char *) "self",(char *) "ownerDrawn", NULL
43533 };
43534
43535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43537 if (!SWIG_IsOK(res1)) {
43538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43539 }
43540 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43541 if (obj1) {
43542 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43543 if (!SWIG_IsOK(ecode2)) {
43544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43545 }
43546 arg2 = static_cast< bool >(val2);
43547 }
43548 {
43549 PyThreadState* __tstate = wxPyBeginAllowThreads();
43550 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43551 wxPyEndAllowThreads(__tstate);
43552 if (PyErr_Occurred()) SWIG_fail;
43553 }
43554 resultobj = SWIG_Py_Void();
43555 return resultobj;
43556 fail:
43557 return NULL;
43558 }
43559
43560
43561 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43562 PyObject *resultobj = 0;
43563 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43564 void *argp1 = 0 ;
43565 int res1 = 0 ;
43566 PyObject *swig_obj[1] ;
43567
43568 if (!args) SWIG_fail;
43569 swig_obj[0] = args;
43570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43571 if (!SWIG_IsOK(res1)) {
43572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43573 }
43574 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43575 {
43576 PyThreadState* __tstate = wxPyBeginAllowThreads();
43577 wxMenuItem_ResetOwnerDrawn(arg1);
43578 wxPyEndAllowThreads(__tstate);
43579 if (PyErr_Occurred()) SWIG_fail;
43580 }
43581 resultobj = SWIG_Py_Void();
43582 return resultobj;
43583 fail:
43584 return NULL;
43585 }
43586
43587
43588 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43589 PyObject *obj;
43590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43591 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43592 return SWIG_Py_Void();
43593 }
43594
43595 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43596 return SWIG_Python_InitShadowInstance(args);
43597 }
43598
43599 SWIGINTERN int ControlNameStr_set(PyObject *) {
43600 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43601 return 1;
43602 }
43603
43604
43605 SWIGINTERN PyObject *ControlNameStr_get(void) {
43606 PyObject *pyobj = 0;
43607
43608 {
43609 #if wxUSE_UNICODE
43610 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43611 #else
43612 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43613 #endif
43614 }
43615 return pyobj;
43616 }
43617
43618
43619 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43620 PyObject *resultobj = 0;
43621 wxWindow *arg1 = (wxWindow *) 0 ;
43622 int arg2 = (int) -1 ;
43623 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43624 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43625 wxSize const &arg4_defvalue = wxDefaultSize ;
43626 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43627 long arg5 = (long) 0 ;
43628 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43629 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43630 wxString const &arg7_defvalue = wxPyControlNameStr ;
43631 wxString *arg7 = (wxString *) &arg7_defvalue ;
43632 wxControl *result = 0 ;
43633 void *argp1 = 0 ;
43634 int res1 = 0 ;
43635 int val2 ;
43636 int ecode2 = 0 ;
43637 wxPoint temp3 ;
43638 wxSize temp4 ;
43639 long val5 ;
43640 int ecode5 = 0 ;
43641 void *argp6 = 0 ;
43642 int res6 = 0 ;
43643 bool temp7 = false ;
43644 PyObject * obj0 = 0 ;
43645 PyObject * obj1 = 0 ;
43646 PyObject * obj2 = 0 ;
43647 PyObject * obj3 = 0 ;
43648 PyObject * obj4 = 0 ;
43649 PyObject * obj5 = 0 ;
43650 PyObject * obj6 = 0 ;
43651 char * kwnames[] = {
43652 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43653 };
43654
43655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43657 if (!SWIG_IsOK(res1)) {
43658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43659 }
43660 arg1 = reinterpret_cast< wxWindow * >(argp1);
43661 if (obj1) {
43662 ecode2 = SWIG_AsVal_int(obj1, &val2);
43663 if (!SWIG_IsOK(ecode2)) {
43664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43665 }
43666 arg2 = static_cast< int >(val2);
43667 }
43668 if (obj2) {
43669 {
43670 arg3 = &temp3;
43671 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43672 }
43673 }
43674 if (obj3) {
43675 {
43676 arg4 = &temp4;
43677 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43678 }
43679 }
43680 if (obj4) {
43681 ecode5 = SWIG_AsVal_long(obj4, &val5);
43682 if (!SWIG_IsOK(ecode5)) {
43683 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43684 }
43685 arg5 = static_cast< long >(val5);
43686 }
43687 if (obj5) {
43688 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43689 if (!SWIG_IsOK(res6)) {
43690 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43691 }
43692 if (!argp6) {
43693 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43694 }
43695 arg6 = reinterpret_cast< wxValidator * >(argp6);
43696 }
43697 if (obj6) {
43698 {
43699 arg7 = wxString_in_helper(obj6);
43700 if (arg7 == NULL) SWIG_fail;
43701 temp7 = true;
43702 }
43703 }
43704 {
43705 if (!wxPyCheckForApp()) SWIG_fail;
43706 PyThreadState* __tstate = wxPyBeginAllowThreads();
43707 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43708 wxPyEndAllowThreads(__tstate);
43709 if (PyErr_Occurred()) SWIG_fail;
43710 }
43711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43712 {
43713 if (temp7)
43714 delete arg7;
43715 }
43716 return resultobj;
43717 fail:
43718 {
43719 if (temp7)
43720 delete arg7;
43721 }
43722 return NULL;
43723 }
43724
43725
43726 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43727 PyObject *resultobj = 0;
43728 wxControl *result = 0 ;
43729
43730 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43731 {
43732 if (!wxPyCheckForApp()) SWIG_fail;
43733 PyThreadState* __tstate = wxPyBeginAllowThreads();
43734 result = (wxControl *)new wxControl();
43735 wxPyEndAllowThreads(__tstate);
43736 if (PyErr_Occurred()) SWIG_fail;
43737 }
43738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43739 return resultobj;
43740 fail:
43741 return NULL;
43742 }
43743
43744
43745 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43746 PyObject *resultobj = 0;
43747 wxControl *arg1 = (wxControl *) 0 ;
43748 wxWindow *arg2 = (wxWindow *) 0 ;
43749 int arg3 = (int) -1 ;
43750 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43751 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43752 wxSize const &arg5_defvalue = wxDefaultSize ;
43753 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43754 long arg6 = (long) 0 ;
43755 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43756 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43757 wxString const &arg8_defvalue = wxPyControlNameStr ;
43758 wxString *arg8 = (wxString *) &arg8_defvalue ;
43759 bool result;
43760 void *argp1 = 0 ;
43761 int res1 = 0 ;
43762 void *argp2 = 0 ;
43763 int res2 = 0 ;
43764 int val3 ;
43765 int ecode3 = 0 ;
43766 wxPoint temp4 ;
43767 wxSize temp5 ;
43768 long val6 ;
43769 int ecode6 = 0 ;
43770 void *argp7 = 0 ;
43771 int res7 = 0 ;
43772 bool temp8 = false ;
43773 PyObject * obj0 = 0 ;
43774 PyObject * obj1 = 0 ;
43775 PyObject * obj2 = 0 ;
43776 PyObject * obj3 = 0 ;
43777 PyObject * obj4 = 0 ;
43778 PyObject * obj5 = 0 ;
43779 PyObject * obj6 = 0 ;
43780 PyObject * obj7 = 0 ;
43781 char * kwnames[] = {
43782 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43783 };
43784
43785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43787 if (!SWIG_IsOK(res1)) {
43788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43789 }
43790 arg1 = reinterpret_cast< wxControl * >(argp1);
43791 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43792 if (!SWIG_IsOK(res2)) {
43793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43794 }
43795 arg2 = reinterpret_cast< wxWindow * >(argp2);
43796 if (obj2) {
43797 ecode3 = SWIG_AsVal_int(obj2, &val3);
43798 if (!SWIG_IsOK(ecode3)) {
43799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43800 }
43801 arg3 = static_cast< int >(val3);
43802 }
43803 if (obj3) {
43804 {
43805 arg4 = &temp4;
43806 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43807 }
43808 }
43809 if (obj4) {
43810 {
43811 arg5 = &temp5;
43812 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43813 }
43814 }
43815 if (obj5) {
43816 ecode6 = SWIG_AsVal_long(obj5, &val6);
43817 if (!SWIG_IsOK(ecode6)) {
43818 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43819 }
43820 arg6 = static_cast< long >(val6);
43821 }
43822 if (obj6) {
43823 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43824 if (!SWIG_IsOK(res7)) {
43825 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43826 }
43827 if (!argp7) {
43828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43829 }
43830 arg7 = reinterpret_cast< wxValidator * >(argp7);
43831 }
43832 if (obj7) {
43833 {
43834 arg8 = wxString_in_helper(obj7);
43835 if (arg8 == NULL) SWIG_fail;
43836 temp8 = true;
43837 }
43838 }
43839 {
43840 PyThreadState* __tstate = wxPyBeginAllowThreads();
43841 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43842 wxPyEndAllowThreads(__tstate);
43843 if (PyErr_Occurred()) SWIG_fail;
43844 }
43845 {
43846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43847 }
43848 {
43849 if (temp8)
43850 delete arg8;
43851 }
43852 return resultobj;
43853 fail:
43854 {
43855 if (temp8)
43856 delete arg8;
43857 }
43858 return NULL;
43859 }
43860
43861
43862 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43863 PyObject *resultobj = 0;
43864 wxControl *arg1 = (wxControl *) 0 ;
43865 wxCommandEvent *arg2 = 0 ;
43866 void *argp1 = 0 ;
43867 int res1 = 0 ;
43868 void *argp2 = 0 ;
43869 int res2 = 0 ;
43870 PyObject * obj0 = 0 ;
43871 PyObject * obj1 = 0 ;
43872 char * kwnames[] = {
43873 (char *) "self",(char *) "event", NULL
43874 };
43875
43876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43878 if (!SWIG_IsOK(res1)) {
43879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43880 }
43881 arg1 = reinterpret_cast< wxControl * >(argp1);
43882 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43883 if (!SWIG_IsOK(res2)) {
43884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43885 }
43886 if (!argp2) {
43887 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43888 }
43889 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43890 {
43891 PyThreadState* __tstate = wxPyBeginAllowThreads();
43892 (arg1)->Command(*arg2);
43893 wxPyEndAllowThreads(__tstate);
43894 if (PyErr_Occurred()) SWIG_fail;
43895 }
43896 resultobj = SWIG_Py_Void();
43897 return resultobj;
43898 fail:
43899 return NULL;
43900 }
43901
43902
43903 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43904 PyObject *resultobj = 0;
43905 wxControl *arg1 = (wxControl *) 0 ;
43906 wxString result;
43907 void *argp1 = 0 ;
43908 int res1 = 0 ;
43909 PyObject *swig_obj[1] ;
43910
43911 if (!args) SWIG_fail;
43912 swig_obj[0] = args;
43913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43914 if (!SWIG_IsOK(res1)) {
43915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43916 }
43917 arg1 = reinterpret_cast< wxControl * >(argp1);
43918 {
43919 PyThreadState* __tstate = wxPyBeginAllowThreads();
43920 result = (arg1)->GetLabel();
43921 wxPyEndAllowThreads(__tstate);
43922 if (PyErr_Occurred()) SWIG_fail;
43923 }
43924 {
43925 #if wxUSE_UNICODE
43926 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43927 #else
43928 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43929 #endif
43930 }
43931 return resultobj;
43932 fail:
43933 return NULL;
43934 }
43935
43936
43937 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43938 PyObject *resultobj = 0;
43939 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43940 SwigValueWrapper<wxVisualAttributes > result;
43941 int val1 ;
43942 int ecode1 = 0 ;
43943 PyObject * obj0 = 0 ;
43944 char * kwnames[] = {
43945 (char *) "variant", NULL
43946 };
43947
43948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43949 if (obj0) {
43950 ecode1 = SWIG_AsVal_int(obj0, &val1);
43951 if (!SWIG_IsOK(ecode1)) {
43952 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43953 }
43954 arg1 = static_cast< wxWindowVariant >(val1);
43955 }
43956 {
43957 if (!wxPyCheckForApp()) SWIG_fail;
43958 PyThreadState* __tstate = wxPyBeginAllowThreads();
43959 result = wxControl::GetClassDefaultAttributes(arg1);
43960 wxPyEndAllowThreads(__tstate);
43961 if (PyErr_Occurred()) SWIG_fail;
43962 }
43963 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43964 return resultobj;
43965 fail:
43966 return NULL;
43967 }
43968
43969
43970 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43971 PyObject *obj;
43972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43973 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43974 return SWIG_Py_Void();
43975 }
43976
43977 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43978 return SWIG_Python_InitShadowInstance(args);
43979 }
43980
43981 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43982 PyObject *resultobj = 0;
43983 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43984 wxString *arg2 = 0 ;
43985 PyObject *arg3 = (PyObject *) NULL ;
43986 int result;
43987 void *argp1 = 0 ;
43988 int res1 = 0 ;
43989 bool temp2 = false ;
43990 PyObject * obj0 = 0 ;
43991 PyObject * obj1 = 0 ;
43992 PyObject * obj2 = 0 ;
43993 char * kwnames[] = {
43994 (char *) "self",(char *) "item",(char *) "clientData", NULL
43995 };
43996
43997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43999 if (!SWIG_IsOK(res1)) {
44000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44001 }
44002 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44003 {
44004 arg2 = wxString_in_helper(obj1);
44005 if (arg2 == NULL) SWIG_fail;
44006 temp2 = true;
44007 }
44008 if (obj2) {
44009 arg3 = obj2;
44010 }
44011 {
44012 PyThreadState* __tstate = wxPyBeginAllowThreads();
44013 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44014 wxPyEndAllowThreads(__tstate);
44015 if (PyErr_Occurred()) SWIG_fail;
44016 }
44017 resultobj = SWIG_From_int(static_cast< int >(result));
44018 {
44019 if (temp2)
44020 delete arg2;
44021 }
44022 return resultobj;
44023 fail:
44024 {
44025 if (temp2)
44026 delete arg2;
44027 }
44028 return NULL;
44029 }
44030
44031
44032 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44033 PyObject *resultobj = 0;
44034 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44035 wxArrayString *arg2 = 0 ;
44036 void *argp1 = 0 ;
44037 int res1 = 0 ;
44038 bool temp2 = false ;
44039 PyObject * obj0 = 0 ;
44040 PyObject * obj1 = 0 ;
44041 char * kwnames[] = {
44042 (char *) "self",(char *) "strings", NULL
44043 };
44044
44045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44047 if (!SWIG_IsOK(res1)) {
44048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44049 }
44050 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44051 {
44052 if (! PySequence_Check(obj1)) {
44053 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44054 SWIG_fail;
44055 }
44056 arg2 = new wxArrayString;
44057 temp2 = true;
44058 int i, len=PySequence_Length(obj1);
44059 for (i=0; i<len; i++) {
44060 PyObject* item = PySequence_GetItem(obj1, i);
44061 wxString* s = wxString_in_helper(item);
44062 if (PyErr_Occurred()) SWIG_fail;
44063 arg2->Add(*s);
44064 delete s;
44065 Py_DECREF(item);
44066 }
44067 }
44068 {
44069 PyThreadState* __tstate = wxPyBeginAllowThreads();
44070 (arg1)->Append((wxArrayString const &)*arg2);
44071 wxPyEndAllowThreads(__tstate);
44072 if (PyErr_Occurred()) SWIG_fail;
44073 }
44074 resultobj = SWIG_Py_Void();
44075 {
44076 if (temp2) delete arg2;
44077 }
44078 return resultobj;
44079 fail:
44080 {
44081 if (temp2) delete arg2;
44082 }
44083 return NULL;
44084 }
44085
44086
44087 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44088 PyObject *resultobj = 0;
44089 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44090 wxString *arg2 = 0 ;
44091 unsigned int arg3 ;
44092 PyObject *arg4 = (PyObject *) NULL ;
44093 int result;
44094 void *argp1 = 0 ;
44095 int res1 = 0 ;
44096 bool temp2 = false ;
44097 unsigned int val3 ;
44098 int ecode3 = 0 ;
44099 PyObject * obj0 = 0 ;
44100 PyObject * obj1 = 0 ;
44101 PyObject * obj2 = 0 ;
44102 PyObject * obj3 = 0 ;
44103 char * kwnames[] = {
44104 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44105 };
44106
44107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44109 if (!SWIG_IsOK(res1)) {
44110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44111 }
44112 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44113 {
44114 arg2 = wxString_in_helper(obj1);
44115 if (arg2 == NULL) SWIG_fail;
44116 temp2 = true;
44117 }
44118 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44119 if (!SWIG_IsOK(ecode3)) {
44120 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44121 }
44122 arg3 = static_cast< unsigned int >(val3);
44123 if (obj3) {
44124 arg4 = obj3;
44125 }
44126 {
44127 PyThreadState* __tstate = wxPyBeginAllowThreads();
44128 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44129 wxPyEndAllowThreads(__tstate);
44130 if (PyErr_Occurred()) SWIG_fail;
44131 }
44132 resultobj = SWIG_From_int(static_cast< int >(result));
44133 {
44134 if (temp2)
44135 delete arg2;
44136 }
44137 return resultobj;
44138 fail:
44139 {
44140 if (temp2)
44141 delete arg2;
44142 }
44143 return NULL;
44144 }
44145
44146
44147 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44148 PyObject *resultobj = 0;
44149 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44150 void *argp1 = 0 ;
44151 int res1 = 0 ;
44152 PyObject *swig_obj[1] ;
44153
44154 if (!args) SWIG_fail;
44155 swig_obj[0] = args;
44156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44157 if (!SWIG_IsOK(res1)) {
44158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44159 }
44160 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44161 {
44162 PyThreadState* __tstate = wxPyBeginAllowThreads();
44163 (arg1)->Clear();
44164 wxPyEndAllowThreads(__tstate);
44165 if (PyErr_Occurred()) SWIG_fail;
44166 }
44167 resultobj = SWIG_Py_Void();
44168 return resultobj;
44169 fail:
44170 return NULL;
44171 }
44172
44173
44174 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44175 PyObject *resultobj = 0;
44176 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44177 unsigned int arg2 ;
44178 void *argp1 = 0 ;
44179 int res1 = 0 ;
44180 unsigned int val2 ;
44181 int ecode2 = 0 ;
44182 PyObject * obj0 = 0 ;
44183 PyObject * obj1 = 0 ;
44184 char * kwnames[] = {
44185 (char *) "self",(char *) "n", NULL
44186 };
44187
44188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44190 if (!SWIG_IsOK(res1)) {
44191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44192 }
44193 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44194 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44195 if (!SWIG_IsOK(ecode2)) {
44196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44197 }
44198 arg2 = static_cast< unsigned int >(val2);
44199 {
44200 PyThreadState* __tstate = wxPyBeginAllowThreads();
44201 (arg1)->Delete(arg2);
44202 wxPyEndAllowThreads(__tstate);
44203 if (PyErr_Occurred()) SWIG_fail;
44204 }
44205 resultobj = SWIG_Py_Void();
44206 return resultobj;
44207 fail:
44208 return NULL;
44209 }
44210
44211
44212 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44213 PyObject *resultobj = 0;
44214 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44215 unsigned int arg2 ;
44216 PyObject *result = 0 ;
44217 void *argp1 = 0 ;
44218 int res1 = 0 ;
44219 unsigned int val2 ;
44220 int ecode2 = 0 ;
44221 PyObject * obj0 = 0 ;
44222 PyObject * obj1 = 0 ;
44223 char * kwnames[] = {
44224 (char *) "self",(char *) "n", NULL
44225 };
44226
44227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44229 if (!SWIG_IsOK(res1)) {
44230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44231 }
44232 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44233 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44234 if (!SWIG_IsOK(ecode2)) {
44235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44236 }
44237 arg2 = static_cast< unsigned int >(val2);
44238 {
44239 PyThreadState* __tstate = wxPyBeginAllowThreads();
44240 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44241 wxPyEndAllowThreads(__tstate);
44242 if (PyErr_Occurred()) SWIG_fail;
44243 }
44244 resultobj = result;
44245 return resultobj;
44246 fail:
44247 return NULL;
44248 }
44249
44250
44251 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44252 PyObject *resultobj = 0;
44253 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44254 unsigned int arg2 ;
44255 PyObject *arg3 = (PyObject *) 0 ;
44256 void *argp1 = 0 ;
44257 int res1 = 0 ;
44258 unsigned int val2 ;
44259 int ecode2 = 0 ;
44260 PyObject * obj0 = 0 ;
44261 PyObject * obj1 = 0 ;
44262 PyObject * obj2 = 0 ;
44263 char * kwnames[] = {
44264 (char *) "self",(char *) "n",(char *) "clientData", NULL
44265 };
44266
44267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44269 if (!SWIG_IsOK(res1)) {
44270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44271 }
44272 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44273 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44274 if (!SWIG_IsOK(ecode2)) {
44275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44276 }
44277 arg2 = static_cast< unsigned int >(val2);
44278 arg3 = obj2;
44279 {
44280 PyThreadState* __tstate = wxPyBeginAllowThreads();
44281 wxItemContainer_SetClientData(arg1,arg2,arg3);
44282 wxPyEndAllowThreads(__tstate);
44283 if (PyErr_Occurred()) SWIG_fail;
44284 }
44285 resultobj = SWIG_Py_Void();
44286 return resultobj;
44287 fail:
44288 return NULL;
44289 }
44290
44291
44292 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44293 PyObject *resultobj = 0;
44294 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44295 unsigned int result;
44296 void *argp1 = 0 ;
44297 int res1 = 0 ;
44298 PyObject *swig_obj[1] ;
44299
44300 if (!args) SWIG_fail;
44301 swig_obj[0] = args;
44302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44303 if (!SWIG_IsOK(res1)) {
44304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44305 }
44306 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44307 {
44308 PyThreadState* __tstate = wxPyBeginAllowThreads();
44309 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44310 wxPyEndAllowThreads(__tstate);
44311 if (PyErr_Occurred()) SWIG_fail;
44312 }
44313 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44314 return resultobj;
44315 fail:
44316 return NULL;
44317 }
44318
44319
44320 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44321 PyObject *resultobj = 0;
44322 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44323 bool result;
44324 void *argp1 = 0 ;
44325 int res1 = 0 ;
44326 PyObject *swig_obj[1] ;
44327
44328 if (!args) SWIG_fail;
44329 swig_obj[0] = args;
44330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44331 if (!SWIG_IsOK(res1)) {
44332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44333 }
44334 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44335 {
44336 PyThreadState* __tstate = wxPyBeginAllowThreads();
44337 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44338 wxPyEndAllowThreads(__tstate);
44339 if (PyErr_Occurred()) SWIG_fail;
44340 }
44341 {
44342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44343 }
44344 return resultobj;
44345 fail:
44346 return NULL;
44347 }
44348
44349
44350 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44351 PyObject *resultobj = 0;
44352 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44353 unsigned int arg2 ;
44354 wxString result;
44355 void *argp1 = 0 ;
44356 int res1 = 0 ;
44357 unsigned int val2 ;
44358 int ecode2 = 0 ;
44359 PyObject * obj0 = 0 ;
44360 PyObject * obj1 = 0 ;
44361 char * kwnames[] = {
44362 (char *) "self",(char *) "n", NULL
44363 };
44364
44365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44367 if (!SWIG_IsOK(res1)) {
44368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44369 }
44370 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44371 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44372 if (!SWIG_IsOK(ecode2)) {
44373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44374 }
44375 arg2 = static_cast< unsigned int >(val2);
44376 {
44377 PyThreadState* __tstate = wxPyBeginAllowThreads();
44378 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44379 wxPyEndAllowThreads(__tstate);
44380 if (PyErr_Occurred()) SWIG_fail;
44381 }
44382 {
44383 #if wxUSE_UNICODE
44384 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44385 #else
44386 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44387 #endif
44388 }
44389 return resultobj;
44390 fail:
44391 return NULL;
44392 }
44393
44394
44395 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44396 PyObject *resultobj = 0;
44397 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44398 wxArrayString result;
44399 void *argp1 = 0 ;
44400 int res1 = 0 ;
44401 PyObject *swig_obj[1] ;
44402
44403 if (!args) SWIG_fail;
44404 swig_obj[0] = args;
44405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44406 if (!SWIG_IsOK(res1)) {
44407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44408 }
44409 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44410 {
44411 PyThreadState* __tstate = wxPyBeginAllowThreads();
44412 result = ((wxItemContainer const *)arg1)->GetStrings();
44413 wxPyEndAllowThreads(__tstate);
44414 if (PyErr_Occurred()) SWIG_fail;
44415 }
44416 {
44417 resultobj = wxArrayString2PyList_helper(result);
44418 }
44419 return resultobj;
44420 fail:
44421 return NULL;
44422 }
44423
44424
44425 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44426 PyObject *resultobj = 0;
44427 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44428 unsigned int arg2 ;
44429 wxString *arg3 = 0 ;
44430 void *argp1 = 0 ;
44431 int res1 = 0 ;
44432 unsigned int val2 ;
44433 int ecode2 = 0 ;
44434 bool temp3 = false ;
44435 PyObject * obj0 = 0 ;
44436 PyObject * obj1 = 0 ;
44437 PyObject * obj2 = 0 ;
44438 char * kwnames[] = {
44439 (char *) "self",(char *) "n",(char *) "s", NULL
44440 };
44441
44442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44444 if (!SWIG_IsOK(res1)) {
44445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44446 }
44447 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44448 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44449 if (!SWIG_IsOK(ecode2)) {
44450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44451 }
44452 arg2 = static_cast< unsigned int >(val2);
44453 {
44454 arg3 = wxString_in_helper(obj2);
44455 if (arg3 == NULL) SWIG_fail;
44456 temp3 = true;
44457 }
44458 {
44459 PyThreadState* __tstate = wxPyBeginAllowThreads();
44460 (arg1)->SetString(arg2,(wxString const &)*arg3);
44461 wxPyEndAllowThreads(__tstate);
44462 if (PyErr_Occurred()) SWIG_fail;
44463 }
44464 resultobj = SWIG_Py_Void();
44465 {
44466 if (temp3)
44467 delete arg3;
44468 }
44469 return resultobj;
44470 fail:
44471 {
44472 if (temp3)
44473 delete arg3;
44474 }
44475 return NULL;
44476 }
44477
44478
44479 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44480 PyObject *resultobj = 0;
44481 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44482 wxString *arg2 = 0 ;
44483 int result;
44484 void *argp1 = 0 ;
44485 int res1 = 0 ;
44486 bool temp2 = false ;
44487 PyObject * obj0 = 0 ;
44488 PyObject * obj1 = 0 ;
44489 char * kwnames[] = {
44490 (char *) "self",(char *) "s", NULL
44491 };
44492
44493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44495 if (!SWIG_IsOK(res1)) {
44496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44497 }
44498 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44499 {
44500 arg2 = wxString_in_helper(obj1);
44501 if (arg2 == NULL) SWIG_fail;
44502 temp2 = true;
44503 }
44504 {
44505 PyThreadState* __tstate = wxPyBeginAllowThreads();
44506 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44507 wxPyEndAllowThreads(__tstate);
44508 if (PyErr_Occurred()) SWIG_fail;
44509 }
44510 resultobj = SWIG_From_int(static_cast< int >(result));
44511 {
44512 if (temp2)
44513 delete arg2;
44514 }
44515 return resultobj;
44516 fail:
44517 {
44518 if (temp2)
44519 delete arg2;
44520 }
44521 return NULL;
44522 }
44523
44524
44525 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44526 PyObject *resultobj = 0;
44527 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44528 int arg2 ;
44529 void *argp1 = 0 ;
44530 int res1 = 0 ;
44531 int val2 ;
44532 int ecode2 = 0 ;
44533 PyObject * obj0 = 0 ;
44534 PyObject * obj1 = 0 ;
44535 char * kwnames[] = {
44536 (char *) "self",(char *) "n", NULL
44537 };
44538
44539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44541 if (!SWIG_IsOK(res1)) {
44542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44543 }
44544 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44545 ecode2 = SWIG_AsVal_int(obj1, &val2);
44546 if (!SWIG_IsOK(ecode2)) {
44547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44548 }
44549 arg2 = static_cast< int >(val2);
44550 {
44551 PyThreadState* __tstate = wxPyBeginAllowThreads();
44552 (arg1)->SetSelection(arg2);
44553 wxPyEndAllowThreads(__tstate);
44554 if (PyErr_Occurred()) SWIG_fail;
44555 }
44556 resultobj = SWIG_Py_Void();
44557 return resultobj;
44558 fail:
44559 return NULL;
44560 }
44561
44562
44563 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44564 PyObject *resultobj = 0;
44565 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44566 int result;
44567 void *argp1 = 0 ;
44568 int res1 = 0 ;
44569 PyObject *swig_obj[1] ;
44570
44571 if (!args) SWIG_fail;
44572 swig_obj[0] = args;
44573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44574 if (!SWIG_IsOK(res1)) {
44575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44576 }
44577 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44578 {
44579 PyThreadState* __tstate = wxPyBeginAllowThreads();
44580 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44581 wxPyEndAllowThreads(__tstate);
44582 if (PyErr_Occurred()) SWIG_fail;
44583 }
44584 resultobj = SWIG_From_int(static_cast< int >(result));
44585 return resultobj;
44586 fail:
44587 return NULL;
44588 }
44589
44590
44591 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44592 PyObject *resultobj = 0;
44593 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44594 wxString *arg2 = 0 ;
44595 bool result;
44596 void *argp1 = 0 ;
44597 int res1 = 0 ;
44598 bool temp2 = false ;
44599 PyObject * obj0 = 0 ;
44600 PyObject * obj1 = 0 ;
44601 char * kwnames[] = {
44602 (char *) "self",(char *) "s", NULL
44603 };
44604
44605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44607 if (!SWIG_IsOK(res1)) {
44608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44609 }
44610 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44611 {
44612 arg2 = wxString_in_helper(obj1);
44613 if (arg2 == NULL) SWIG_fail;
44614 temp2 = true;
44615 }
44616 {
44617 PyThreadState* __tstate = wxPyBeginAllowThreads();
44618 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44619 wxPyEndAllowThreads(__tstate);
44620 if (PyErr_Occurred()) SWIG_fail;
44621 }
44622 {
44623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44624 }
44625 {
44626 if (temp2)
44627 delete arg2;
44628 }
44629 return resultobj;
44630 fail:
44631 {
44632 if (temp2)
44633 delete arg2;
44634 }
44635 return NULL;
44636 }
44637
44638
44639 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44640 PyObject *resultobj = 0;
44641 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44642 wxString result;
44643 void *argp1 = 0 ;
44644 int res1 = 0 ;
44645 PyObject *swig_obj[1] ;
44646
44647 if (!args) SWIG_fail;
44648 swig_obj[0] = args;
44649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44650 if (!SWIG_IsOK(res1)) {
44651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44652 }
44653 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44654 {
44655 PyThreadState* __tstate = wxPyBeginAllowThreads();
44656 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44657 wxPyEndAllowThreads(__tstate);
44658 if (PyErr_Occurred()) SWIG_fail;
44659 }
44660 {
44661 #if wxUSE_UNICODE
44662 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44663 #else
44664 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44665 #endif
44666 }
44667 return resultobj;
44668 fail:
44669 return NULL;
44670 }
44671
44672
44673 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44674 PyObject *resultobj = 0;
44675 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44676 int arg2 ;
44677 void *argp1 = 0 ;
44678 int res1 = 0 ;
44679 int val2 ;
44680 int ecode2 = 0 ;
44681 PyObject * obj0 = 0 ;
44682 PyObject * obj1 = 0 ;
44683 char * kwnames[] = {
44684 (char *) "self",(char *) "n", NULL
44685 };
44686
44687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44689 if (!SWIG_IsOK(res1)) {
44690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44691 }
44692 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44693 ecode2 = SWIG_AsVal_int(obj1, &val2);
44694 if (!SWIG_IsOK(ecode2)) {
44695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44696 }
44697 arg2 = static_cast< int >(val2);
44698 {
44699 PyThreadState* __tstate = wxPyBeginAllowThreads();
44700 (arg1)->Select(arg2);
44701 wxPyEndAllowThreads(__tstate);
44702 if (PyErr_Occurred()) SWIG_fail;
44703 }
44704 resultobj = SWIG_Py_Void();
44705 return resultobj;
44706 fail:
44707 return NULL;
44708 }
44709
44710
44711 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44712 PyObject *obj;
44713 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44714 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44715 return SWIG_Py_Void();
44716 }
44717
44718 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44719 PyObject *obj;
44720 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44721 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44722 return SWIG_Py_Void();
44723 }
44724
44725 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44726 PyObject *resultobj = 0;
44727 wxSizerItem *result = 0 ;
44728
44729 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44730 {
44731 PyThreadState* __tstate = wxPyBeginAllowThreads();
44732 result = (wxSizerItem *)new wxSizerItem();
44733 wxPyEndAllowThreads(__tstate);
44734 if (PyErr_Occurred()) SWIG_fail;
44735 }
44736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44737 return resultobj;
44738 fail:
44739 return NULL;
44740 }
44741
44742
44743 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44744 PyObject *resultobj = 0;
44745 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44746 void *argp1 = 0 ;
44747 int res1 = 0 ;
44748 PyObject *swig_obj[1] ;
44749
44750 if (!args) SWIG_fail;
44751 swig_obj[0] = args;
44752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44753 if (!SWIG_IsOK(res1)) {
44754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44755 }
44756 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44757 {
44758 PyThreadState* __tstate = wxPyBeginAllowThreads();
44759 delete arg1;
44760
44761 wxPyEndAllowThreads(__tstate);
44762 if (PyErr_Occurred()) SWIG_fail;
44763 }
44764 resultobj = SWIG_Py_Void();
44765 return resultobj;
44766 fail:
44767 return NULL;
44768 }
44769
44770
44771 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44772 PyObject *resultobj = 0;
44773 wxWindow *arg1 = (wxWindow *) 0 ;
44774 int arg2 ;
44775 int arg3 ;
44776 int arg4 ;
44777 PyObject *arg5 = (PyObject *) NULL ;
44778 wxSizerItem *result = 0 ;
44779 void *argp1 = 0 ;
44780 int res1 = 0 ;
44781 int val2 ;
44782 int ecode2 = 0 ;
44783 int val3 ;
44784 int ecode3 = 0 ;
44785 int val4 ;
44786 int ecode4 = 0 ;
44787 PyObject * obj0 = 0 ;
44788 PyObject * obj1 = 0 ;
44789 PyObject * obj2 = 0 ;
44790 PyObject * obj3 = 0 ;
44791 PyObject * obj4 = 0 ;
44792 char * kwnames[] = {
44793 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44794 };
44795
44796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44798 if (!SWIG_IsOK(res1)) {
44799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44800 }
44801 arg1 = reinterpret_cast< wxWindow * >(argp1);
44802 ecode2 = SWIG_AsVal_int(obj1, &val2);
44803 if (!SWIG_IsOK(ecode2)) {
44804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44805 }
44806 arg2 = static_cast< int >(val2);
44807 ecode3 = SWIG_AsVal_int(obj2, &val3);
44808 if (!SWIG_IsOK(ecode3)) {
44809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44810 }
44811 arg3 = static_cast< int >(val3);
44812 ecode4 = SWIG_AsVal_int(obj3, &val4);
44813 if (!SWIG_IsOK(ecode4)) {
44814 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44815 }
44816 arg4 = static_cast< int >(val4);
44817 if (obj4) {
44818 arg5 = obj4;
44819 }
44820 {
44821 PyThreadState* __tstate = wxPyBeginAllowThreads();
44822 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44823 wxPyEndAllowThreads(__tstate);
44824 if (PyErr_Occurred()) SWIG_fail;
44825 }
44826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44827 return resultobj;
44828 fail:
44829 return NULL;
44830 }
44831
44832
44833 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44834 PyObject *resultobj = 0;
44835 int arg1 ;
44836 int arg2 ;
44837 int arg3 ;
44838 int arg4 ;
44839 int arg5 ;
44840 PyObject *arg6 = (PyObject *) NULL ;
44841 wxSizerItem *result = 0 ;
44842 int val1 ;
44843 int ecode1 = 0 ;
44844 int val2 ;
44845 int ecode2 = 0 ;
44846 int val3 ;
44847 int ecode3 = 0 ;
44848 int val4 ;
44849 int ecode4 = 0 ;
44850 int val5 ;
44851 int ecode5 = 0 ;
44852 PyObject * obj0 = 0 ;
44853 PyObject * obj1 = 0 ;
44854 PyObject * obj2 = 0 ;
44855 PyObject * obj3 = 0 ;
44856 PyObject * obj4 = 0 ;
44857 PyObject * obj5 = 0 ;
44858 char * kwnames[] = {
44859 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44860 };
44861
44862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44863 ecode1 = SWIG_AsVal_int(obj0, &val1);
44864 if (!SWIG_IsOK(ecode1)) {
44865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44866 }
44867 arg1 = static_cast< int >(val1);
44868 ecode2 = SWIG_AsVal_int(obj1, &val2);
44869 if (!SWIG_IsOK(ecode2)) {
44870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44871 }
44872 arg2 = static_cast< int >(val2);
44873 ecode3 = SWIG_AsVal_int(obj2, &val3);
44874 if (!SWIG_IsOK(ecode3)) {
44875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44876 }
44877 arg3 = static_cast< int >(val3);
44878 ecode4 = SWIG_AsVal_int(obj3, &val4);
44879 if (!SWIG_IsOK(ecode4)) {
44880 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44881 }
44882 arg4 = static_cast< int >(val4);
44883 ecode5 = SWIG_AsVal_int(obj4, &val5);
44884 if (!SWIG_IsOK(ecode5)) {
44885 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44886 }
44887 arg5 = static_cast< int >(val5);
44888 if (obj5) {
44889 arg6 = obj5;
44890 }
44891 {
44892 PyThreadState* __tstate = wxPyBeginAllowThreads();
44893 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44894 wxPyEndAllowThreads(__tstate);
44895 if (PyErr_Occurred()) SWIG_fail;
44896 }
44897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44898 return resultobj;
44899 fail:
44900 return NULL;
44901 }
44902
44903
44904 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44905 PyObject *resultobj = 0;
44906 wxSizer *arg1 = (wxSizer *) 0 ;
44907 int arg2 ;
44908 int arg3 ;
44909 int arg4 ;
44910 PyObject *arg5 = (PyObject *) NULL ;
44911 wxSizerItem *result = 0 ;
44912 int res1 = 0 ;
44913 int val2 ;
44914 int ecode2 = 0 ;
44915 int val3 ;
44916 int ecode3 = 0 ;
44917 int val4 ;
44918 int ecode4 = 0 ;
44919 PyObject * obj0 = 0 ;
44920 PyObject * obj1 = 0 ;
44921 PyObject * obj2 = 0 ;
44922 PyObject * obj3 = 0 ;
44923 PyObject * obj4 = 0 ;
44924 char * kwnames[] = {
44925 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44926 };
44927
44928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44929 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44930 if (!SWIG_IsOK(res1)) {
44931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44932 }
44933 ecode2 = SWIG_AsVal_int(obj1, &val2);
44934 if (!SWIG_IsOK(ecode2)) {
44935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44936 }
44937 arg2 = static_cast< int >(val2);
44938 ecode3 = SWIG_AsVal_int(obj2, &val3);
44939 if (!SWIG_IsOK(ecode3)) {
44940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44941 }
44942 arg3 = static_cast< int >(val3);
44943 ecode4 = SWIG_AsVal_int(obj3, &val4);
44944 if (!SWIG_IsOK(ecode4)) {
44945 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44946 }
44947 arg4 = static_cast< int >(val4);
44948 if (obj4) {
44949 arg5 = obj4;
44950 }
44951 {
44952 PyThreadState* __tstate = wxPyBeginAllowThreads();
44953 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44954 wxPyEndAllowThreads(__tstate);
44955 if (PyErr_Occurred()) SWIG_fail;
44956 }
44957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44958 return resultobj;
44959 fail:
44960 return NULL;
44961 }
44962
44963
44964 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44965 PyObject *resultobj = 0;
44966 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44967 void *argp1 = 0 ;
44968 int res1 = 0 ;
44969 PyObject *swig_obj[1] ;
44970
44971 if (!args) SWIG_fail;
44972 swig_obj[0] = args;
44973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44974 if (!SWIG_IsOK(res1)) {
44975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44976 }
44977 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44978 {
44979 PyThreadState* __tstate = wxPyBeginAllowThreads();
44980 (arg1)->DeleteWindows();
44981 wxPyEndAllowThreads(__tstate);
44982 if (PyErr_Occurred()) SWIG_fail;
44983 }
44984 resultobj = SWIG_Py_Void();
44985 return resultobj;
44986 fail:
44987 return NULL;
44988 }
44989
44990
44991 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44992 PyObject *resultobj = 0;
44993 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44994 void *argp1 = 0 ;
44995 int res1 = 0 ;
44996 PyObject *swig_obj[1] ;
44997
44998 if (!args) SWIG_fail;
44999 swig_obj[0] = args;
45000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45001 if (!SWIG_IsOK(res1)) {
45002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45003 }
45004 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45005 {
45006 PyThreadState* __tstate = wxPyBeginAllowThreads();
45007 (arg1)->DetachSizer();
45008 wxPyEndAllowThreads(__tstate);
45009 if (PyErr_Occurred()) SWIG_fail;
45010 }
45011 resultobj = SWIG_Py_Void();
45012 return resultobj;
45013 fail:
45014 return NULL;
45015 }
45016
45017
45018 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45019 PyObject *resultobj = 0;
45020 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45021 wxSize result;
45022 void *argp1 = 0 ;
45023 int res1 = 0 ;
45024 PyObject *swig_obj[1] ;
45025
45026 if (!args) SWIG_fail;
45027 swig_obj[0] = args;
45028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45029 if (!SWIG_IsOK(res1)) {
45030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45031 }
45032 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45033 {
45034 PyThreadState* __tstate = wxPyBeginAllowThreads();
45035 result = (arg1)->GetSize();
45036 wxPyEndAllowThreads(__tstate);
45037 if (PyErr_Occurred()) SWIG_fail;
45038 }
45039 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45040 return resultobj;
45041 fail:
45042 return NULL;
45043 }
45044
45045
45046 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45047 PyObject *resultobj = 0;
45048 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45049 wxSize result;
45050 void *argp1 = 0 ;
45051 int res1 = 0 ;
45052 PyObject *swig_obj[1] ;
45053
45054 if (!args) SWIG_fail;
45055 swig_obj[0] = args;
45056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45057 if (!SWIG_IsOK(res1)) {
45058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45059 }
45060 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45061 {
45062 PyThreadState* __tstate = wxPyBeginAllowThreads();
45063 result = (arg1)->CalcMin();
45064 wxPyEndAllowThreads(__tstate);
45065 if (PyErr_Occurred()) SWIG_fail;
45066 }
45067 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45068 return resultobj;
45069 fail:
45070 return NULL;
45071 }
45072
45073
45074 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45075 PyObject *resultobj = 0;
45076 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45077 wxPoint *arg2 = 0 ;
45078 wxSize *arg3 = 0 ;
45079 void *argp1 = 0 ;
45080 int res1 = 0 ;
45081 wxPoint temp2 ;
45082 wxSize temp3 ;
45083 PyObject * obj0 = 0 ;
45084 PyObject * obj1 = 0 ;
45085 PyObject * obj2 = 0 ;
45086 char * kwnames[] = {
45087 (char *) "self",(char *) "pos",(char *) "size", NULL
45088 };
45089
45090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45092 if (!SWIG_IsOK(res1)) {
45093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45094 }
45095 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45096 {
45097 arg2 = &temp2;
45098 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45099 }
45100 {
45101 arg3 = &temp3;
45102 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45103 }
45104 {
45105 PyThreadState* __tstate = wxPyBeginAllowThreads();
45106 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45107 wxPyEndAllowThreads(__tstate);
45108 if (PyErr_Occurred()) SWIG_fail;
45109 }
45110 resultobj = SWIG_Py_Void();
45111 return resultobj;
45112 fail:
45113 return NULL;
45114 }
45115
45116
45117 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45118 PyObject *resultobj = 0;
45119 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45120 wxSize result;
45121 void *argp1 = 0 ;
45122 int res1 = 0 ;
45123 PyObject *swig_obj[1] ;
45124
45125 if (!args) SWIG_fail;
45126 swig_obj[0] = args;
45127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45128 if (!SWIG_IsOK(res1)) {
45129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45130 }
45131 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45132 {
45133 PyThreadState* __tstate = wxPyBeginAllowThreads();
45134 result = (arg1)->GetMinSize();
45135 wxPyEndAllowThreads(__tstate);
45136 if (PyErr_Occurred()) SWIG_fail;
45137 }
45138 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45139 return resultobj;
45140 fail:
45141 return NULL;
45142 }
45143
45144
45145 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45146 PyObject *resultobj = 0;
45147 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45148 wxSize result;
45149 void *argp1 = 0 ;
45150 int res1 = 0 ;
45151 PyObject *swig_obj[1] ;
45152
45153 if (!args) SWIG_fail;
45154 swig_obj[0] = args;
45155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45156 if (!SWIG_IsOK(res1)) {
45157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45158 }
45159 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45160 {
45161 PyThreadState* __tstate = wxPyBeginAllowThreads();
45162 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45163 wxPyEndAllowThreads(__tstate);
45164 if (PyErr_Occurred()) SWIG_fail;
45165 }
45166 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45167 return resultobj;
45168 fail:
45169 return NULL;
45170 }
45171
45172
45173 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45174 PyObject *resultobj = 0;
45175 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45176 int arg2 ;
45177 int arg3 ;
45178 void *argp1 = 0 ;
45179 int res1 = 0 ;
45180 int val2 ;
45181 int ecode2 = 0 ;
45182 int val3 ;
45183 int ecode3 = 0 ;
45184 PyObject * obj0 = 0 ;
45185 PyObject * obj1 = 0 ;
45186 PyObject * obj2 = 0 ;
45187 char * kwnames[] = {
45188 (char *) "self",(char *) "x",(char *) "y", NULL
45189 };
45190
45191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45193 if (!SWIG_IsOK(res1)) {
45194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45195 }
45196 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45197 ecode2 = SWIG_AsVal_int(obj1, &val2);
45198 if (!SWIG_IsOK(ecode2)) {
45199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45200 }
45201 arg2 = static_cast< int >(val2);
45202 ecode3 = SWIG_AsVal_int(obj2, &val3);
45203 if (!SWIG_IsOK(ecode3)) {
45204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45205 }
45206 arg3 = static_cast< int >(val3);
45207 {
45208 PyThreadState* __tstate = wxPyBeginAllowThreads();
45209 (arg1)->SetInitSize(arg2,arg3);
45210 wxPyEndAllowThreads(__tstate);
45211 if (PyErr_Occurred()) SWIG_fail;
45212 }
45213 resultobj = SWIG_Py_Void();
45214 return resultobj;
45215 fail:
45216 return NULL;
45217 }
45218
45219
45220 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45221 PyObject *resultobj = 0;
45222 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45223 int arg2 ;
45224 int arg3 ;
45225 void *argp1 = 0 ;
45226 int res1 = 0 ;
45227 int val2 ;
45228 int ecode2 = 0 ;
45229 int val3 ;
45230 int ecode3 = 0 ;
45231 PyObject * obj0 = 0 ;
45232 PyObject * obj1 = 0 ;
45233 PyObject * obj2 = 0 ;
45234 char * kwnames[] = {
45235 (char *) "self",(char *) "width",(char *) "height", NULL
45236 };
45237
45238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45240 if (!SWIG_IsOK(res1)) {
45241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45242 }
45243 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45244 ecode2 = SWIG_AsVal_int(obj1, &val2);
45245 if (!SWIG_IsOK(ecode2)) {
45246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45247 }
45248 arg2 = static_cast< int >(val2);
45249 ecode3 = SWIG_AsVal_int(obj2, &val3);
45250 if (!SWIG_IsOK(ecode3)) {
45251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45252 }
45253 arg3 = static_cast< int >(val3);
45254 {
45255 PyThreadState* __tstate = wxPyBeginAllowThreads();
45256 (arg1)->SetRatio(arg2,arg3);
45257 wxPyEndAllowThreads(__tstate);
45258 if (PyErr_Occurred()) SWIG_fail;
45259 }
45260 resultobj = SWIG_Py_Void();
45261 return resultobj;
45262 fail:
45263 return NULL;
45264 }
45265
45266
45267 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45268 PyObject *resultobj = 0;
45269 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45270 wxSize *arg2 = 0 ;
45271 void *argp1 = 0 ;
45272 int res1 = 0 ;
45273 wxSize temp2 ;
45274 PyObject * obj0 = 0 ;
45275 PyObject * obj1 = 0 ;
45276 char * kwnames[] = {
45277 (char *) "self",(char *) "size", NULL
45278 };
45279
45280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45282 if (!SWIG_IsOK(res1)) {
45283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45284 }
45285 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45286 {
45287 arg2 = &temp2;
45288 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45289 }
45290 {
45291 PyThreadState* __tstate = wxPyBeginAllowThreads();
45292 (arg1)->SetRatio((wxSize const &)*arg2);
45293 wxPyEndAllowThreads(__tstate);
45294 if (PyErr_Occurred()) SWIG_fail;
45295 }
45296 resultobj = SWIG_Py_Void();
45297 return resultobj;
45298 fail:
45299 return NULL;
45300 }
45301
45302
45303 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45304 PyObject *resultobj = 0;
45305 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45306 float arg2 ;
45307 void *argp1 = 0 ;
45308 int res1 = 0 ;
45309 float val2 ;
45310 int ecode2 = 0 ;
45311 PyObject * obj0 = 0 ;
45312 PyObject * obj1 = 0 ;
45313 char * kwnames[] = {
45314 (char *) "self",(char *) "ratio", NULL
45315 };
45316
45317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45319 if (!SWIG_IsOK(res1)) {
45320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45321 }
45322 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45323 ecode2 = SWIG_AsVal_float(obj1, &val2);
45324 if (!SWIG_IsOK(ecode2)) {
45325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45326 }
45327 arg2 = static_cast< float >(val2);
45328 {
45329 PyThreadState* __tstate = wxPyBeginAllowThreads();
45330 (arg1)->SetRatio(arg2);
45331 wxPyEndAllowThreads(__tstate);
45332 if (PyErr_Occurred()) SWIG_fail;
45333 }
45334 resultobj = SWIG_Py_Void();
45335 return resultobj;
45336 fail:
45337 return NULL;
45338 }
45339
45340
45341 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45342 PyObject *resultobj = 0;
45343 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45344 float result;
45345 void *argp1 = 0 ;
45346 int res1 = 0 ;
45347 PyObject *swig_obj[1] ;
45348
45349 if (!args) SWIG_fail;
45350 swig_obj[0] = args;
45351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45352 if (!SWIG_IsOK(res1)) {
45353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45354 }
45355 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45356 {
45357 PyThreadState* __tstate = wxPyBeginAllowThreads();
45358 result = (float)(arg1)->GetRatio();
45359 wxPyEndAllowThreads(__tstate);
45360 if (PyErr_Occurred()) SWIG_fail;
45361 }
45362 resultobj = SWIG_From_float(static_cast< float >(result));
45363 return resultobj;
45364 fail:
45365 return NULL;
45366 }
45367
45368
45369 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45370 PyObject *resultobj = 0;
45371 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45372 wxRect result;
45373 void *argp1 = 0 ;
45374 int res1 = 0 ;
45375 PyObject *swig_obj[1] ;
45376
45377 if (!args) SWIG_fail;
45378 swig_obj[0] = args;
45379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45380 if (!SWIG_IsOK(res1)) {
45381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45382 }
45383 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45384 {
45385 PyThreadState* __tstate = wxPyBeginAllowThreads();
45386 result = (arg1)->GetRect();
45387 wxPyEndAllowThreads(__tstate);
45388 if (PyErr_Occurred()) SWIG_fail;
45389 }
45390 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45391 return resultobj;
45392 fail:
45393 return NULL;
45394 }
45395
45396
45397 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45398 PyObject *resultobj = 0;
45399 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45400 bool result;
45401 void *argp1 = 0 ;
45402 int res1 = 0 ;
45403 PyObject *swig_obj[1] ;
45404
45405 if (!args) SWIG_fail;
45406 swig_obj[0] = args;
45407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45408 if (!SWIG_IsOK(res1)) {
45409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45410 }
45411 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45412 {
45413 PyThreadState* __tstate = wxPyBeginAllowThreads();
45414 result = (bool)(arg1)->IsWindow();
45415 wxPyEndAllowThreads(__tstate);
45416 if (PyErr_Occurred()) SWIG_fail;
45417 }
45418 {
45419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45420 }
45421 return resultobj;
45422 fail:
45423 return NULL;
45424 }
45425
45426
45427 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45428 PyObject *resultobj = 0;
45429 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45430 bool result;
45431 void *argp1 = 0 ;
45432 int res1 = 0 ;
45433 PyObject *swig_obj[1] ;
45434
45435 if (!args) SWIG_fail;
45436 swig_obj[0] = args;
45437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45438 if (!SWIG_IsOK(res1)) {
45439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45440 }
45441 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45442 {
45443 PyThreadState* __tstate = wxPyBeginAllowThreads();
45444 result = (bool)(arg1)->IsSizer();
45445 wxPyEndAllowThreads(__tstate);
45446 if (PyErr_Occurred()) SWIG_fail;
45447 }
45448 {
45449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45450 }
45451 return resultobj;
45452 fail:
45453 return NULL;
45454 }
45455
45456
45457 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45458 PyObject *resultobj = 0;
45459 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45460 bool 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_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45470 }
45471 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45472 {
45473 PyThreadState* __tstate = wxPyBeginAllowThreads();
45474 result = (bool)(arg1)->IsSpacer();
45475 wxPyEndAllowThreads(__tstate);
45476 if (PyErr_Occurred()) SWIG_fail;
45477 }
45478 {
45479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45480 }
45481 return resultobj;
45482 fail:
45483 return NULL;
45484 }
45485
45486
45487 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45488 PyObject *resultobj = 0;
45489 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45490 int arg2 ;
45491 void *argp1 = 0 ;
45492 int res1 = 0 ;
45493 int val2 ;
45494 int ecode2 = 0 ;
45495 PyObject * obj0 = 0 ;
45496 PyObject * obj1 = 0 ;
45497 char * kwnames[] = {
45498 (char *) "self",(char *) "proportion", NULL
45499 };
45500
45501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45503 if (!SWIG_IsOK(res1)) {
45504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45505 }
45506 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45507 ecode2 = SWIG_AsVal_int(obj1, &val2);
45508 if (!SWIG_IsOK(ecode2)) {
45509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45510 }
45511 arg2 = static_cast< int >(val2);
45512 {
45513 PyThreadState* __tstate = wxPyBeginAllowThreads();
45514 (arg1)->SetProportion(arg2);
45515 wxPyEndAllowThreads(__tstate);
45516 if (PyErr_Occurred()) SWIG_fail;
45517 }
45518 resultobj = SWIG_Py_Void();
45519 return resultobj;
45520 fail:
45521 return NULL;
45522 }
45523
45524
45525 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45526 PyObject *resultobj = 0;
45527 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45528 int result;
45529 void *argp1 = 0 ;
45530 int res1 = 0 ;
45531 PyObject *swig_obj[1] ;
45532
45533 if (!args) SWIG_fail;
45534 swig_obj[0] = args;
45535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45536 if (!SWIG_IsOK(res1)) {
45537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45538 }
45539 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45540 {
45541 PyThreadState* __tstate = wxPyBeginAllowThreads();
45542 result = (int)(arg1)->GetProportion();
45543 wxPyEndAllowThreads(__tstate);
45544 if (PyErr_Occurred()) SWIG_fail;
45545 }
45546 resultobj = SWIG_From_int(static_cast< int >(result));
45547 return resultobj;
45548 fail:
45549 return NULL;
45550 }
45551
45552
45553 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45554 PyObject *resultobj = 0;
45555 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45556 int arg2 ;
45557 void *argp1 = 0 ;
45558 int res1 = 0 ;
45559 int val2 ;
45560 int ecode2 = 0 ;
45561 PyObject * obj0 = 0 ;
45562 PyObject * obj1 = 0 ;
45563 char * kwnames[] = {
45564 (char *) "self",(char *) "flag", NULL
45565 };
45566
45567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45569 if (!SWIG_IsOK(res1)) {
45570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45571 }
45572 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45573 ecode2 = SWIG_AsVal_int(obj1, &val2);
45574 if (!SWIG_IsOK(ecode2)) {
45575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45576 }
45577 arg2 = static_cast< int >(val2);
45578 {
45579 PyThreadState* __tstate = wxPyBeginAllowThreads();
45580 (arg1)->SetFlag(arg2);
45581 wxPyEndAllowThreads(__tstate);
45582 if (PyErr_Occurred()) SWIG_fail;
45583 }
45584 resultobj = SWIG_Py_Void();
45585 return resultobj;
45586 fail:
45587 return NULL;
45588 }
45589
45590
45591 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45592 PyObject *resultobj = 0;
45593 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45594 int result;
45595 void *argp1 = 0 ;
45596 int res1 = 0 ;
45597 PyObject *swig_obj[1] ;
45598
45599 if (!args) SWIG_fail;
45600 swig_obj[0] = args;
45601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45602 if (!SWIG_IsOK(res1)) {
45603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45604 }
45605 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45606 {
45607 PyThreadState* __tstate = wxPyBeginAllowThreads();
45608 result = (int)(arg1)->GetFlag();
45609 wxPyEndAllowThreads(__tstate);
45610 if (PyErr_Occurred()) SWIG_fail;
45611 }
45612 resultobj = SWIG_From_int(static_cast< int >(result));
45613 return resultobj;
45614 fail:
45615 return NULL;
45616 }
45617
45618
45619 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45620 PyObject *resultobj = 0;
45621 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45622 int arg2 ;
45623 void *argp1 = 0 ;
45624 int res1 = 0 ;
45625 int val2 ;
45626 int ecode2 = 0 ;
45627 PyObject * obj0 = 0 ;
45628 PyObject * obj1 = 0 ;
45629 char * kwnames[] = {
45630 (char *) "self",(char *) "border", NULL
45631 };
45632
45633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45635 if (!SWIG_IsOK(res1)) {
45636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45637 }
45638 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45639 ecode2 = SWIG_AsVal_int(obj1, &val2);
45640 if (!SWIG_IsOK(ecode2)) {
45641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45642 }
45643 arg2 = static_cast< int >(val2);
45644 {
45645 PyThreadState* __tstate = wxPyBeginAllowThreads();
45646 (arg1)->SetBorder(arg2);
45647 wxPyEndAllowThreads(__tstate);
45648 if (PyErr_Occurred()) SWIG_fail;
45649 }
45650 resultobj = SWIG_Py_Void();
45651 return resultobj;
45652 fail:
45653 return NULL;
45654 }
45655
45656
45657 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45658 PyObject *resultobj = 0;
45659 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45660 int result;
45661 void *argp1 = 0 ;
45662 int res1 = 0 ;
45663 PyObject *swig_obj[1] ;
45664
45665 if (!args) SWIG_fail;
45666 swig_obj[0] = args;
45667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45668 if (!SWIG_IsOK(res1)) {
45669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45670 }
45671 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45672 {
45673 PyThreadState* __tstate = wxPyBeginAllowThreads();
45674 result = (int)(arg1)->GetBorder();
45675 wxPyEndAllowThreads(__tstate);
45676 if (PyErr_Occurred()) SWIG_fail;
45677 }
45678 resultobj = SWIG_From_int(static_cast< int >(result));
45679 return resultobj;
45680 fail:
45681 return NULL;
45682 }
45683
45684
45685 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45686 PyObject *resultobj = 0;
45687 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45688 wxWindow *result = 0 ;
45689 void *argp1 = 0 ;
45690 int res1 = 0 ;
45691 PyObject *swig_obj[1] ;
45692
45693 if (!args) SWIG_fail;
45694 swig_obj[0] = args;
45695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45696 if (!SWIG_IsOK(res1)) {
45697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45698 }
45699 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45700 {
45701 PyThreadState* __tstate = wxPyBeginAllowThreads();
45702 result = (wxWindow *)(arg1)->GetWindow();
45703 wxPyEndAllowThreads(__tstate);
45704 if (PyErr_Occurred()) SWIG_fail;
45705 }
45706 {
45707 resultobj = wxPyMake_wxObject(result, 0);
45708 }
45709 return resultobj;
45710 fail:
45711 return NULL;
45712 }
45713
45714
45715 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45716 PyObject *resultobj = 0;
45717 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45718 wxWindow *arg2 = (wxWindow *) 0 ;
45719 void *argp1 = 0 ;
45720 int res1 = 0 ;
45721 void *argp2 = 0 ;
45722 int res2 = 0 ;
45723 PyObject * obj0 = 0 ;
45724 PyObject * obj1 = 0 ;
45725 char * kwnames[] = {
45726 (char *) "self",(char *) "window", NULL
45727 };
45728
45729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45731 if (!SWIG_IsOK(res1)) {
45732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45733 }
45734 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45735 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45736 if (!SWIG_IsOK(res2)) {
45737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45738 }
45739 arg2 = reinterpret_cast< wxWindow * >(argp2);
45740 {
45741 PyThreadState* __tstate = wxPyBeginAllowThreads();
45742 (arg1)->SetWindow(arg2);
45743 wxPyEndAllowThreads(__tstate);
45744 if (PyErr_Occurred()) SWIG_fail;
45745 }
45746 resultobj = SWIG_Py_Void();
45747 return resultobj;
45748 fail:
45749 return NULL;
45750 }
45751
45752
45753 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45754 PyObject *resultobj = 0;
45755 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45756 wxSizer *result = 0 ;
45757 void *argp1 = 0 ;
45758 int res1 = 0 ;
45759 PyObject *swig_obj[1] ;
45760
45761 if (!args) SWIG_fail;
45762 swig_obj[0] = args;
45763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45764 if (!SWIG_IsOK(res1)) {
45765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45766 }
45767 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45768 {
45769 PyThreadState* __tstate = wxPyBeginAllowThreads();
45770 result = (wxSizer *)(arg1)->GetSizer();
45771 wxPyEndAllowThreads(__tstate);
45772 if (PyErr_Occurred()) SWIG_fail;
45773 }
45774 {
45775 resultobj = wxPyMake_wxObject(result, (bool)0);
45776 }
45777 return resultobj;
45778 fail:
45779 return NULL;
45780 }
45781
45782
45783 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45784 PyObject *resultobj = 0;
45785 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45786 wxSizer *arg2 = (wxSizer *) 0 ;
45787 void *argp1 = 0 ;
45788 int res1 = 0 ;
45789 int res2 = 0 ;
45790 PyObject * obj0 = 0 ;
45791 PyObject * obj1 = 0 ;
45792 char * kwnames[] = {
45793 (char *) "self",(char *) "sizer", NULL
45794 };
45795
45796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45798 if (!SWIG_IsOK(res1)) {
45799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45800 }
45801 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45802 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45803 if (!SWIG_IsOK(res2)) {
45804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45805 }
45806 {
45807 PyThreadState* __tstate = wxPyBeginAllowThreads();
45808 (arg1)->SetSizer(arg2);
45809 wxPyEndAllowThreads(__tstate);
45810 if (PyErr_Occurred()) SWIG_fail;
45811 }
45812 resultobj = SWIG_Py_Void();
45813 return resultobj;
45814 fail:
45815 return NULL;
45816 }
45817
45818
45819 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45820 PyObject *resultobj = 0;
45821 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45822 wxSize *result = 0 ;
45823 void *argp1 = 0 ;
45824 int res1 = 0 ;
45825 PyObject *swig_obj[1] ;
45826
45827 if (!args) SWIG_fail;
45828 swig_obj[0] = args;
45829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45830 if (!SWIG_IsOK(res1)) {
45831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45832 }
45833 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45834 {
45835 PyThreadState* __tstate = wxPyBeginAllowThreads();
45836 {
45837 wxSize const &_result_ref = (arg1)->GetSpacer();
45838 result = (wxSize *) &_result_ref;
45839 }
45840 wxPyEndAllowThreads(__tstate);
45841 if (PyErr_Occurred()) SWIG_fail;
45842 }
45843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45844 return resultobj;
45845 fail:
45846 return NULL;
45847 }
45848
45849
45850 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45851 PyObject *resultobj = 0;
45852 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45853 wxSize *arg2 = 0 ;
45854 void *argp1 = 0 ;
45855 int res1 = 0 ;
45856 wxSize temp2 ;
45857 PyObject * obj0 = 0 ;
45858 PyObject * obj1 = 0 ;
45859 char * kwnames[] = {
45860 (char *) "self",(char *) "size", NULL
45861 };
45862
45863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45865 if (!SWIG_IsOK(res1)) {
45866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45867 }
45868 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45869 {
45870 arg2 = &temp2;
45871 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45872 }
45873 {
45874 PyThreadState* __tstate = wxPyBeginAllowThreads();
45875 (arg1)->SetSpacer((wxSize const &)*arg2);
45876 wxPyEndAllowThreads(__tstate);
45877 if (PyErr_Occurred()) SWIG_fail;
45878 }
45879 resultobj = SWIG_Py_Void();
45880 return resultobj;
45881 fail:
45882 return NULL;
45883 }
45884
45885
45886 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45887 PyObject *resultobj = 0;
45888 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45889 bool arg2 ;
45890 void *argp1 = 0 ;
45891 int res1 = 0 ;
45892 bool val2 ;
45893 int ecode2 = 0 ;
45894 PyObject * obj0 = 0 ;
45895 PyObject * obj1 = 0 ;
45896 char * kwnames[] = {
45897 (char *) "self",(char *) "show", NULL
45898 };
45899
45900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45902 if (!SWIG_IsOK(res1)) {
45903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45904 }
45905 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45906 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45907 if (!SWIG_IsOK(ecode2)) {
45908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45909 }
45910 arg2 = static_cast< bool >(val2);
45911 {
45912 PyThreadState* __tstate = wxPyBeginAllowThreads();
45913 (arg1)->Show(arg2);
45914 wxPyEndAllowThreads(__tstate);
45915 if (PyErr_Occurred()) SWIG_fail;
45916 }
45917 resultobj = SWIG_Py_Void();
45918 return resultobj;
45919 fail:
45920 return NULL;
45921 }
45922
45923
45924 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45925 PyObject *resultobj = 0;
45926 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45927 bool result;
45928 void *argp1 = 0 ;
45929 int res1 = 0 ;
45930 PyObject *swig_obj[1] ;
45931
45932 if (!args) SWIG_fail;
45933 swig_obj[0] = args;
45934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45935 if (!SWIG_IsOK(res1)) {
45936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45937 }
45938 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45939 {
45940 PyThreadState* __tstate = wxPyBeginAllowThreads();
45941 result = (bool)(arg1)->IsShown();
45942 wxPyEndAllowThreads(__tstate);
45943 if (PyErr_Occurred()) SWIG_fail;
45944 }
45945 {
45946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45947 }
45948 return resultobj;
45949 fail:
45950 return NULL;
45951 }
45952
45953
45954 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45955 PyObject *resultobj = 0;
45956 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45957 wxPoint result;
45958 void *argp1 = 0 ;
45959 int res1 = 0 ;
45960 PyObject *swig_obj[1] ;
45961
45962 if (!args) SWIG_fail;
45963 swig_obj[0] = args;
45964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45965 if (!SWIG_IsOK(res1)) {
45966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45967 }
45968 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45969 {
45970 PyThreadState* __tstate = wxPyBeginAllowThreads();
45971 result = (arg1)->GetPosition();
45972 wxPyEndAllowThreads(__tstate);
45973 if (PyErr_Occurred()) SWIG_fail;
45974 }
45975 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45976 return resultobj;
45977 fail:
45978 return NULL;
45979 }
45980
45981
45982 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45983 PyObject *resultobj = 0;
45984 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45985 PyObject *result = 0 ;
45986 void *argp1 = 0 ;
45987 int res1 = 0 ;
45988 PyObject *swig_obj[1] ;
45989
45990 if (!args) SWIG_fail;
45991 swig_obj[0] = args;
45992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45993 if (!SWIG_IsOK(res1)) {
45994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45995 }
45996 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45997 {
45998 PyThreadState* __tstate = wxPyBeginAllowThreads();
45999 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46000 wxPyEndAllowThreads(__tstate);
46001 if (PyErr_Occurred()) SWIG_fail;
46002 }
46003 resultobj = result;
46004 return resultobj;
46005 fail:
46006 return NULL;
46007 }
46008
46009
46010 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46011 PyObject *resultobj = 0;
46012 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46013 PyObject *arg2 = (PyObject *) 0 ;
46014 void *argp1 = 0 ;
46015 int res1 = 0 ;
46016 PyObject * obj0 = 0 ;
46017 PyObject * obj1 = 0 ;
46018 char * kwnames[] = {
46019 (char *) "self",(char *) "userData", NULL
46020 };
46021
46022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46024 if (!SWIG_IsOK(res1)) {
46025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46026 }
46027 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46028 arg2 = obj1;
46029 {
46030 PyThreadState* __tstate = wxPyBeginAllowThreads();
46031 wxSizerItem_SetUserData(arg1,arg2);
46032 wxPyEndAllowThreads(__tstate);
46033 if (PyErr_Occurred()) SWIG_fail;
46034 }
46035 resultobj = SWIG_Py_Void();
46036 return resultobj;
46037 fail:
46038 return NULL;
46039 }
46040
46041
46042 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46043 PyObject *obj;
46044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46045 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46046 return SWIG_Py_Void();
46047 }
46048
46049 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46050 return SWIG_Python_InitShadowInstance(args);
46051 }
46052
46053 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46054 PyObject *resultobj = 0;
46055 wxSizer *arg1 = (wxSizer *) 0 ;
46056 void *argp1 = 0 ;
46057 int res1 = 0 ;
46058 PyObject *swig_obj[1] ;
46059
46060 if (!args) SWIG_fail;
46061 swig_obj[0] = args;
46062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46063 if (!SWIG_IsOK(res1)) {
46064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46065 }
46066 arg1 = reinterpret_cast< wxSizer * >(argp1);
46067 {
46068 PyThreadState* __tstate = wxPyBeginAllowThreads();
46069 delete arg1;
46070
46071 wxPyEndAllowThreads(__tstate);
46072 if (PyErr_Occurred()) SWIG_fail;
46073 }
46074 resultobj = SWIG_Py_Void();
46075 return resultobj;
46076 fail:
46077 return NULL;
46078 }
46079
46080
46081 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46082 PyObject *resultobj = 0;
46083 wxSizer *arg1 = (wxSizer *) 0 ;
46084 PyObject *arg2 = (PyObject *) 0 ;
46085 void *argp1 = 0 ;
46086 int res1 = 0 ;
46087 PyObject * obj0 = 0 ;
46088 PyObject * obj1 = 0 ;
46089 char * kwnames[] = {
46090 (char *) "self",(char *) "_self", NULL
46091 };
46092
46093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46095 if (!SWIG_IsOK(res1)) {
46096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46097 }
46098 arg1 = reinterpret_cast< wxSizer * >(argp1);
46099 arg2 = obj1;
46100 {
46101 PyThreadState* __tstate = wxPyBeginAllowThreads();
46102 wxSizer__setOORInfo(arg1,arg2);
46103 wxPyEndAllowThreads(__tstate);
46104 if (PyErr_Occurred()) SWIG_fail;
46105 }
46106 resultobj = SWIG_Py_Void();
46107 return resultobj;
46108 fail:
46109 return NULL;
46110 }
46111
46112
46113 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46114 PyObject *resultobj = 0;
46115 wxSizer *arg1 = (wxSizer *) 0 ;
46116 PyObject *arg2 = (PyObject *) 0 ;
46117 int arg3 = (int) 0 ;
46118 int arg4 = (int) 0 ;
46119 int arg5 = (int) 0 ;
46120 PyObject *arg6 = (PyObject *) NULL ;
46121 wxSizerItem *result = 0 ;
46122 void *argp1 = 0 ;
46123 int res1 = 0 ;
46124 int val3 ;
46125 int ecode3 = 0 ;
46126 int val4 ;
46127 int ecode4 = 0 ;
46128 int val5 ;
46129 int ecode5 = 0 ;
46130 PyObject * obj0 = 0 ;
46131 PyObject * obj1 = 0 ;
46132 PyObject * obj2 = 0 ;
46133 PyObject * obj3 = 0 ;
46134 PyObject * obj4 = 0 ;
46135 PyObject * obj5 = 0 ;
46136 char * kwnames[] = {
46137 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46138 };
46139
46140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46142 if (!SWIG_IsOK(res1)) {
46143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46144 }
46145 arg1 = reinterpret_cast< wxSizer * >(argp1);
46146 arg2 = obj1;
46147 if (obj2) {
46148 ecode3 = SWIG_AsVal_int(obj2, &val3);
46149 if (!SWIG_IsOK(ecode3)) {
46150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46151 }
46152 arg3 = static_cast< int >(val3);
46153 }
46154 if (obj3) {
46155 ecode4 = SWIG_AsVal_int(obj3, &val4);
46156 if (!SWIG_IsOK(ecode4)) {
46157 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46158 }
46159 arg4 = static_cast< int >(val4);
46160 }
46161 if (obj4) {
46162 ecode5 = SWIG_AsVal_int(obj4, &val5);
46163 if (!SWIG_IsOK(ecode5)) {
46164 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46165 }
46166 arg5 = static_cast< int >(val5);
46167 }
46168 if (obj5) {
46169 arg6 = obj5;
46170 }
46171 {
46172 PyThreadState* __tstate = wxPyBeginAllowThreads();
46173 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46174 wxPyEndAllowThreads(__tstate);
46175 if (PyErr_Occurred()) SWIG_fail;
46176 }
46177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46178 return resultobj;
46179 fail:
46180 return NULL;
46181 }
46182
46183
46184 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46185 PyObject *resultobj = 0;
46186 wxSizer *arg1 = (wxSizer *) 0 ;
46187 int arg2 ;
46188 PyObject *arg3 = (PyObject *) 0 ;
46189 int arg4 = (int) 0 ;
46190 int arg5 = (int) 0 ;
46191 int arg6 = (int) 0 ;
46192 PyObject *arg7 = (PyObject *) NULL ;
46193 wxSizerItem *result = 0 ;
46194 void *argp1 = 0 ;
46195 int res1 = 0 ;
46196 int val2 ;
46197 int ecode2 = 0 ;
46198 int val4 ;
46199 int ecode4 = 0 ;
46200 int val5 ;
46201 int ecode5 = 0 ;
46202 int val6 ;
46203 int ecode6 = 0 ;
46204 PyObject * obj0 = 0 ;
46205 PyObject * obj1 = 0 ;
46206 PyObject * obj2 = 0 ;
46207 PyObject * obj3 = 0 ;
46208 PyObject * obj4 = 0 ;
46209 PyObject * obj5 = 0 ;
46210 PyObject * obj6 = 0 ;
46211 char * kwnames[] = {
46212 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46213 };
46214
46215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46217 if (!SWIG_IsOK(res1)) {
46218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46219 }
46220 arg1 = reinterpret_cast< wxSizer * >(argp1);
46221 ecode2 = SWIG_AsVal_int(obj1, &val2);
46222 if (!SWIG_IsOK(ecode2)) {
46223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46224 }
46225 arg2 = static_cast< int >(val2);
46226 arg3 = obj2;
46227 if (obj3) {
46228 ecode4 = SWIG_AsVal_int(obj3, &val4);
46229 if (!SWIG_IsOK(ecode4)) {
46230 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46231 }
46232 arg4 = static_cast< int >(val4);
46233 }
46234 if (obj4) {
46235 ecode5 = SWIG_AsVal_int(obj4, &val5);
46236 if (!SWIG_IsOK(ecode5)) {
46237 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46238 }
46239 arg5 = static_cast< int >(val5);
46240 }
46241 if (obj5) {
46242 ecode6 = SWIG_AsVal_int(obj5, &val6);
46243 if (!SWIG_IsOK(ecode6)) {
46244 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46245 }
46246 arg6 = static_cast< int >(val6);
46247 }
46248 if (obj6) {
46249 arg7 = obj6;
46250 }
46251 {
46252 PyThreadState* __tstate = wxPyBeginAllowThreads();
46253 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46254 wxPyEndAllowThreads(__tstate);
46255 if (PyErr_Occurred()) SWIG_fail;
46256 }
46257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46258 return resultobj;
46259 fail:
46260 return NULL;
46261 }
46262
46263
46264 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46265 PyObject *resultobj = 0;
46266 wxSizer *arg1 = (wxSizer *) 0 ;
46267 PyObject *arg2 = (PyObject *) 0 ;
46268 int arg3 = (int) 0 ;
46269 int arg4 = (int) 0 ;
46270 int arg5 = (int) 0 ;
46271 PyObject *arg6 = (PyObject *) NULL ;
46272 wxSizerItem *result = 0 ;
46273 void *argp1 = 0 ;
46274 int res1 = 0 ;
46275 int val3 ;
46276 int ecode3 = 0 ;
46277 int val4 ;
46278 int ecode4 = 0 ;
46279 int val5 ;
46280 int ecode5 = 0 ;
46281 PyObject * obj0 = 0 ;
46282 PyObject * obj1 = 0 ;
46283 PyObject * obj2 = 0 ;
46284 PyObject * obj3 = 0 ;
46285 PyObject * obj4 = 0 ;
46286 PyObject * obj5 = 0 ;
46287 char * kwnames[] = {
46288 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46289 };
46290
46291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46295 }
46296 arg1 = reinterpret_cast< wxSizer * >(argp1);
46297 arg2 = obj1;
46298 if (obj2) {
46299 ecode3 = SWIG_AsVal_int(obj2, &val3);
46300 if (!SWIG_IsOK(ecode3)) {
46301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46302 }
46303 arg3 = static_cast< int >(val3);
46304 }
46305 if (obj3) {
46306 ecode4 = SWIG_AsVal_int(obj3, &val4);
46307 if (!SWIG_IsOK(ecode4)) {
46308 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46309 }
46310 arg4 = static_cast< int >(val4);
46311 }
46312 if (obj4) {
46313 ecode5 = SWIG_AsVal_int(obj4, &val5);
46314 if (!SWIG_IsOK(ecode5)) {
46315 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46316 }
46317 arg5 = static_cast< int >(val5);
46318 }
46319 if (obj5) {
46320 arg6 = obj5;
46321 }
46322 {
46323 PyThreadState* __tstate = wxPyBeginAllowThreads();
46324 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46325 wxPyEndAllowThreads(__tstate);
46326 if (PyErr_Occurred()) SWIG_fail;
46327 }
46328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46329 return resultobj;
46330 fail:
46331 return NULL;
46332 }
46333
46334
46335 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46336 PyObject *resultobj = 0;
46337 wxSizer *arg1 = (wxSizer *) 0 ;
46338 PyObject *arg2 = (PyObject *) 0 ;
46339 bool result;
46340 void *argp1 = 0 ;
46341 int res1 = 0 ;
46342 PyObject * obj0 = 0 ;
46343 PyObject * obj1 = 0 ;
46344 char * kwnames[] = {
46345 (char *) "self",(char *) "item", NULL
46346 };
46347
46348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46350 if (!SWIG_IsOK(res1)) {
46351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46352 }
46353 arg1 = reinterpret_cast< wxSizer * >(argp1);
46354 arg2 = obj1;
46355 {
46356 PyThreadState* __tstate = wxPyBeginAllowThreads();
46357 result = (bool)wxSizer_Remove(arg1,arg2);
46358 wxPyEndAllowThreads(__tstate);
46359 if (PyErr_Occurred()) SWIG_fail;
46360 }
46361 {
46362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46363 }
46364 return resultobj;
46365 fail:
46366 return NULL;
46367 }
46368
46369
46370 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46371 PyObject *resultobj = 0;
46372 wxSizer *arg1 = (wxSizer *) 0 ;
46373 PyObject *arg2 = (PyObject *) 0 ;
46374 bool result;
46375 void *argp1 = 0 ;
46376 int res1 = 0 ;
46377 PyObject * obj0 = 0 ;
46378 PyObject * obj1 = 0 ;
46379 char * kwnames[] = {
46380 (char *) "self",(char *) "item", NULL
46381 };
46382
46383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46385 if (!SWIG_IsOK(res1)) {
46386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46387 }
46388 arg1 = reinterpret_cast< wxSizer * >(argp1);
46389 arg2 = obj1;
46390 {
46391 PyThreadState* __tstate = wxPyBeginAllowThreads();
46392 result = (bool)wxSizer_Detach(arg1,arg2);
46393 wxPyEndAllowThreads(__tstate);
46394 if (PyErr_Occurred()) SWIG_fail;
46395 }
46396 {
46397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46398 }
46399 return resultobj;
46400 fail:
46401 return NULL;
46402 }
46403
46404
46405 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46406 PyObject *resultobj = 0;
46407 wxSizer *arg1 = (wxSizer *) 0 ;
46408 PyObject *arg2 = (PyObject *) 0 ;
46409 wxSizerItem *result = 0 ;
46410 void *argp1 = 0 ;
46411 int res1 = 0 ;
46412 PyObject * obj0 = 0 ;
46413 PyObject * obj1 = 0 ;
46414 char * kwnames[] = {
46415 (char *) "self",(char *) "item", NULL
46416 };
46417
46418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46420 if (!SWIG_IsOK(res1)) {
46421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46422 }
46423 arg1 = reinterpret_cast< wxSizer * >(argp1);
46424 arg2 = obj1;
46425 {
46426 PyThreadState* __tstate = wxPyBeginAllowThreads();
46427 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46428 wxPyEndAllowThreads(__tstate);
46429 if (PyErr_Occurred()) SWIG_fail;
46430 }
46431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46432 return resultobj;
46433 fail:
46434 return NULL;
46435 }
46436
46437
46438 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46439 PyObject *resultobj = 0;
46440 wxSizer *arg1 = (wxSizer *) 0 ;
46441 PyObject *arg2 = (PyObject *) 0 ;
46442 wxSize *arg3 = 0 ;
46443 void *argp1 = 0 ;
46444 int res1 = 0 ;
46445 wxSize temp3 ;
46446 PyObject * obj0 = 0 ;
46447 PyObject * obj1 = 0 ;
46448 PyObject * obj2 = 0 ;
46449 char * kwnames[] = {
46450 (char *) "self",(char *) "item",(char *) "size", NULL
46451 };
46452
46453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46455 if (!SWIG_IsOK(res1)) {
46456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46457 }
46458 arg1 = reinterpret_cast< wxSizer * >(argp1);
46459 arg2 = obj1;
46460 {
46461 arg3 = &temp3;
46462 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46463 }
46464 {
46465 PyThreadState* __tstate = wxPyBeginAllowThreads();
46466 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46467 wxPyEndAllowThreads(__tstate);
46468 if (PyErr_Occurred()) SWIG_fail;
46469 }
46470 resultobj = SWIG_Py_Void();
46471 return resultobj;
46472 fail:
46473 return NULL;
46474 }
46475
46476
46477 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46478 PyObject *resultobj = 0;
46479 wxSizer *arg1 = (wxSizer *) 0 ;
46480 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46481 wxSizerItem *result = 0 ;
46482 void *argp1 = 0 ;
46483 int res1 = 0 ;
46484 int res2 = 0 ;
46485 PyObject * obj0 = 0 ;
46486 PyObject * obj1 = 0 ;
46487 char * kwnames[] = {
46488 (char *) "self",(char *) "item", NULL
46489 };
46490
46491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46493 if (!SWIG_IsOK(res1)) {
46494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46495 }
46496 arg1 = reinterpret_cast< wxSizer * >(argp1);
46497 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46498 if (!SWIG_IsOK(res2)) {
46499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46500 }
46501 {
46502 PyThreadState* __tstate = wxPyBeginAllowThreads();
46503 result = (wxSizerItem *)(arg1)->Add(arg2);
46504 wxPyEndAllowThreads(__tstate);
46505 if (PyErr_Occurred()) SWIG_fail;
46506 }
46507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46508 return resultobj;
46509 fail:
46510 return NULL;
46511 }
46512
46513
46514 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46515 PyObject *resultobj = 0;
46516 wxSizer *arg1 = (wxSizer *) 0 ;
46517 size_t arg2 ;
46518 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46519 wxSizerItem *result = 0 ;
46520 void *argp1 = 0 ;
46521 int res1 = 0 ;
46522 size_t val2 ;
46523 int ecode2 = 0 ;
46524 int res3 = 0 ;
46525 PyObject * obj0 = 0 ;
46526 PyObject * obj1 = 0 ;
46527 PyObject * obj2 = 0 ;
46528 char * kwnames[] = {
46529 (char *) "self",(char *) "index",(char *) "item", NULL
46530 };
46531
46532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46534 if (!SWIG_IsOK(res1)) {
46535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46536 }
46537 arg1 = reinterpret_cast< wxSizer * >(argp1);
46538 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46539 if (!SWIG_IsOK(ecode2)) {
46540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46541 }
46542 arg2 = static_cast< size_t >(val2);
46543 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46544 if (!SWIG_IsOK(res3)) {
46545 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46546 }
46547 {
46548 PyThreadState* __tstate = wxPyBeginAllowThreads();
46549 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46550 wxPyEndAllowThreads(__tstate);
46551 if (PyErr_Occurred()) SWIG_fail;
46552 }
46553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46554 return resultobj;
46555 fail:
46556 return NULL;
46557 }
46558
46559
46560 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46561 PyObject *resultobj = 0;
46562 wxSizer *arg1 = (wxSizer *) 0 ;
46563 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46564 wxSizerItem *result = 0 ;
46565 void *argp1 = 0 ;
46566 int res1 = 0 ;
46567 int res2 = 0 ;
46568 PyObject * obj0 = 0 ;
46569 PyObject * obj1 = 0 ;
46570 char * kwnames[] = {
46571 (char *) "self",(char *) "item", NULL
46572 };
46573
46574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46576 if (!SWIG_IsOK(res1)) {
46577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46578 }
46579 arg1 = reinterpret_cast< wxSizer * >(argp1);
46580 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46581 if (!SWIG_IsOK(res2)) {
46582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46583 }
46584 {
46585 PyThreadState* __tstate = wxPyBeginAllowThreads();
46586 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46587 wxPyEndAllowThreads(__tstate);
46588 if (PyErr_Occurred()) SWIG_fail;
46589 }
46590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46591 return resultobj;
46592 fail:
46593 return NULL;
46594 }
46595
46596
46597 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46598 PyObject *resultobj = 0;
46599 wxSizer *arg1 = (wxSizer *) 0 ;
46600 int arg2 ;
46601 int arg3 ;
46602 int arg4 ;
46603 int arg5 ;
46604 void *argp1 = 0 ;
46605 int res1 = 0 ;
46606 int val2 ;
46607 int ecode2 = 0 ;
46608 int val3 ;
46609 int ecode3 = 0 ;
46610 int val4 ;
46611 int ecode4 = 0 ;
46612 int val5 ;
46613 int ecode5 = 0 ;
46614 PyObject * obj0 = 0 ;
46615 PyObject * obj1 = 0 ;
46616 PyObject * obj2 = 0 ;
46617 PyObject * obj3 = 0 ;
46618 PyObject * obj4 = 0 ;
46619 char * kwnames[] = {
46620 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46621 };
46622
46623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46625 if (!SWIG_IsOK(res1)) {
46626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46627 }
46628 arg1 = reinterpret_cast< wxSizer * >(argp1);
46629 ecode2 = SWIG_AsVal_int(obj1, &val2);
46630 if (!SWIG_IsOK(ecode2)) {
46631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46632 }
46633 arg2 = static_cast< int >(val2);
46634 ecode3 = SWIG_AsVal_int(obj2, &val3);
46635 if (!SWIG_IsOK(ecode3)) {
46636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46637 }
46638 arg3 = static_cast< int >(val3);
46639 ecode4 = SWIG_AsVal_int(obj3, &val4);
46640 if (!SWIG_IsOK(ecode4)) {
46641 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46642 }
46643 arg4 = static_cast< int >(val4);
46644 ecode5 = SWIG_AsVal_int(obj4, &val5);
46645 if (!SWIG_IsOK(ecode5)) {
46646 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46647 }
46648 arg5 = static_cast< int >(val5);
46649 {
46650 PyThreadState* __tstate = wxPyBeginAllowThreads();
46651 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46652 wxPyEndAllowThreads(__tstate);
46653 if (PyErr_Occurred()) SWIG_fail;
46654 }
46655 resultobj = SWIG_Py_Void();
46656 return resultobj;
46657 fail:
46658 return NULL;
46659 }
46660
46661
46662 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46663 PyObject *resultobj = 0;
46664 wxSizer *arg1 = (wxSizer *) 0 ;
46665 wxSize *arg2 = 0 ;
46666 void *argp1 = 0 ;
46667 int res1 = 0 ;
46668 wxSize temp2 ;
46669 PyObject * obj0 = 0 ;
46670 PyObject * obj1 = 0 ;
46671 char * kwnames[] = {
46672 (char *) "self",(char *) "size", NULL
46673 };
46674
46675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46677 if (!SWIG_IsOK(res1)) {
46678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46679 }
46680 arg1 = reinterpret_cast< wxSizer * >(argp1);
46681 {
46682 arg2 = &temp2;
46683 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46684 }
46685 {
46686 PyThreadState* __tstate = wxPyBeginAllowThreads();
46687 (arg1)->SetMinSize((wxSize const &)*arg2);
46688 wxPyEndAllowThreads(__tstate);
46689 if (PyErr_Occurred()) SWIG_fail;
46690 }
46691 resultobj = SWIG_Py_Void();
46692 return resultobj;
46693 fail:
46694 return NULL;
46695 }
46696
46697
46698 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46699 PyObject *resultobj = 0;
46700 wxSizer *arg1 = (wxSizer *) 0 ;
46701 wxSize result;
46702 void *argp1 = 0 ;
46703 int res1 = 0 ;
46704 PyObject *swig_obj[1] ;
46705
46706 if (!args) SWIG_fail;
46707 swig_obj[0] = args;
46708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46709 if (!SWIG_IsOK(res1)) {
46710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46711 }
46712 arg1 = reinterpret_cast< wxSizer * >(argp1);
46713 {
46714 PyThreadState* __tstate = wxPyBeginAllowThreads();
46715 result = (arg1)->GetSize();
46716 wxPyEndAllowThreads(__tstate);
46717 if (PyErr_Occurred()) SWIG_fail;
46718 }
46719 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46720 return resultobj;
46721 fail:
46722 return NULL;
46723 }
46724
46725
46726 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46727 PyObject *resultobj = 0;
46728 wxSizer *arg1 = (wxSizer *) 0 ;
46729 wxPoint result;
46730 void *argp1 = 0 ;
46731 int res1 = 0 ;
46732 PyObject *swig_obj[1] ;
46733
46734 if (!args) SWIG_fail;
46735 swig_obj[0] = args;
46736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46737 if (!SWIG_IsOK(res1)) {
46738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46739 }
46740 arg1 = reinterpret_cast< wxSizer * >(argp1);
46741 {
46742 PyThreadState* __tstate = wxPyBeginAllowThreads();
46743 result = (arg1)->GetPosition();
46744 wxPyEndAllowThreads(__tstate);
46745 if (PyErr_Occurred()) SWIG_fail;
46746 }
46747 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46748 return resultobj;
46749 fail:
46750 return NULL;
46751 }
46752
46753
46754 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46755 PyObject *resultobj = 0;
46756 wxSizer *arg1 = (wxSizer *) 0 ;
46757 wxSize result;
46758 void *argp1 = 0 ;
46759 int res1 = 0 ;
46760 PyObject *swig_obj[1] ;
46761
46762 if (!args) SWIG_fail;
46763 swig_obj[0] = args;
46764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46765 if (!SWIG_IsOK(res1)) {
46766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46767 }
46768 arg1 = reinterpret_cast< wxSizer * >(argp1);
46769 {
46770 PyThreadState* __tstate = wxPyBeginAllowThreads();
46771 result = (arg1)->GetMinSize();
46772 wxPyEndAllowThreads(__tstate);
46773 if (PyErr_Occurred()) SWIG_fail;
46774 }
46775 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46776 return resultobj;
46777 fail:
46778 return NULL;
46779 }
46780
46781
46782 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46783 PyObject *resultobj = 0;
46784 wxSizer *arg1 = (wxSizer *) 0 ;
46785 void *argp1 = 0 ;
46786 int res1 = 0 ;
46787 PyObject *swig_obj[1] ;
46788
46789 if (!args) SWIG_fail;
46790 swig_obj[0] = args;
46791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46792 if (!SWIG_IsOK(res1)) {
46793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46794 }
46795 arg1 = reinterpret_cast< wxSizer * >(argp1);
46796 {
46797 PyThreadState* __tstate = wxPyBeginAllowThreads();
46798 (arg1)->RecalcSizes();
46799 wxPyEndAllowThreads(__tstate);
46800 if (PyErr_Occurred()) SWIG_fail;
46801 }
46802 resultobj = SWIG_Py_Void();
46803 return resultobj;
46804 fail:
46805 return NULL;
46806 }
46807
46808
46809 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46810 PyObject *resultobj = 0;
46811 wxSizer *arg1 = (wxSizer *) 0 ;
46812 wxSize result;
46813 void *argp1 = 0 ;
46814 int res1 = 0 ;
46815 PyObject *swig_obj[1] ;
46816
46817 if (!args) SWIG_fail;
46818 swig_obj[0] = args;
46819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46820 if (!SWIG_IsOK(res1)) {
46821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46822 }
46823 arg1 = reinterpret_cast< wxSizer * >(argp1);
46824 {
46825 PyThreadState* __tstate = wxPyBeginAllowThreads();
46826 result = (arg1)->CalcMin();
46827 wxPyEndAllowThreads(__tstate);
46828 if (PyErr_Occurred()) SWIG_fail;
46829 }
46830 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46831 return resultobj;
46832 fail:
46833 return NULL;
46834 }
46835
46836
46837 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46838 PyObject *resultobj = 0;
46839 wxSizer *arg1 = (wxSizer *) 0 ;
46840 void *argp1 = 0 ;
46841 int res1 = 0 ;
46842 PyObject *swig_obj[1] ;
46843
46844 if (!args) SWIG_fail;
46845 swig_obj[0] = args;
46846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46847 if (!SWIG_IsOK(res1)) {
46848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46849 }
46850 arg1 = reinterpret_cast< wxSizer * >(argp1);
46851 {
46852 PyThreadState* __tstate = wxPyBeginAllowThreads();
46853 (arg1)->Layout();
46854 wxPyEndAllowThreads(__tstate);
46855 if (PyErr_Occurred()) SWIG_fail;
46856 }
46857 resultobj = SWIG_Py_Void();
46858 return resultobj;
46859 fail:
46860 return NULL;
46861 }
46862
46863
46864 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46865 PyObject *resultobj = 0;
46866 wxSizer *arg1 = (wxSizer *) 0 ;
46867 wxWindow *arg2 = (wxWindow *) 0 ;
46868 wxSize result;
46869 void *argp1 = 0 ;
46870 int res1 = 0 ;
46871 void *argp2 = 0 ;
46872 int res2 = 0 ;
46873 PyObject * obj0 = 0 ;
46874 PyObject * obj1 = 0 ;
46875 char * kwnames[] = {
46876 (char *) "self",(char *) "window", NULL
46877 };
46878
46879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46881 if (!SWIG_IsOK(res1)) {
46882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46883 }
46884 arg1 = reinterpret_cast< wxSizer * >(argp1);
46885 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46886 if (!SWIG_IsOK(res2)) {
46887 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46888 }
46889 arg2 = reinterpret_cast< wxWindow * >(argp2);
46890 {
46891 PyThreadState* __tstate = wxPyBeginAllowThreads();
46892 result = (arg1)->Fit(arg2);
46893 wxPyEndAllowThreads(__tstate);
46894 if (PyErr_Occurred()) SWIG_fail;
46895 }
46896 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46897 return resultobj;
46898 fail:
46899 return NULL;
46900 }
46901
46902
46903 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46904 PyObject *resultobj = 0;
46905 wxSizer *arg1 = (wxSizer *) 0 ;
46906 wxWindow *arg2 = (wxWindow *) 0 ;
46907 void *argp1 = 0 ;
46908 int res1 = 0 ;
46909 void *argp2 = 0 ;
46910 int res2 = 0 ;
46911 PyObject * obj0 = 0 ;
46912 PyObject * obj1 = 0 ;
46913 char * kwnames[] = {
46914 (char *) "self",(char *) "window", NULL
46915 };
46916
46917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46919 if (!SWIG_IsOK(res1)) {
46920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46921 }
46922 arg1 = reinterpret_cast< wxSizer * >(argp1);
46923 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46924 if (!SWIG_IsOK(res2)) {
46925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46926 }
46927 arg2 = reinterpret_cast< wxWindow * >(argp2);
46928 {
46929 PyThreadState* __tstate = wxPyBeginAllowThreads();
46930 (arg1)->FitInside(arg2);
46931 wxPyEndAllowThreads(__tstate);
46932 if (PyErr_Occurred()) SWIG_fail;
46933 }
46934 resultobj = SWIG_Py_Void();
46935 return resultobj;
46936 fail:
46937 return NULL;
46938 }
46939
46940
46941 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46942 PyObject *resultobj = 0;
46943 wxSizer *arg1 = (wxSizer *) 0 ;
46944 wxWindow *arg2 = (wxWindow *) 0 ;
46945 void *argp1 = 0 ;
46946 int res1 = 0 ;
46947 void *argp2 = 0 ;
46948 int res2 = 0 ;
46949 PyObject * obj0 = 0 ;
46950 PyObject * obj1 = 0 ;
46951 char * kwnames[] = {
46952 (char *) "self",(char *) "window", NULL
46953 };
46954
46955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46957 if (!SWIG_IsOK(res1)) {
46958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46959 }
46960 arg1 = reinterpret_cast< wxSizer * >(argp1);
46961 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46962 if (!SWIG_IsOK(res2)) {
46963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46964 }
46965 arg2 = reinterpret_cast< wxWindow * >(argp2);
46966 {
46967 PyThreadState* __tstate = wxPyBeginAllowThreads();
46968 (arg1)->SetSizeHints(arg2);
46969 wxPyEndAllowThreads(__tstate);
46970 if (PyErr_Occurred()) SWIG_fail;
46971 }
46972 resultobj = SWIG_Py_Void();
46973 return resultobj;
46974 fail:
46975 return NULL;
46976 }
46977
46978
46979 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46980 PyObject *resultobj = 0;
46981 wxSizer *arg1 = (wxSizer *) 0 ;
46982 wxWindow *arg2 = (wxWindow *) 0 ;
46983 void *argp1 = 0 ;
46984 int res1 = 0 ;
46985 void *argp2 = 0 ;
46986 int res2 = 0 ;
46987 PyObject * obj0 = 0 ;
46988 PyObject * obj1 = 0 ;
46989 char * kwnames[] = {
46990 (char *) "self",(char *) "window", NULL
46991 };
46992
46993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46995 if (!SWIG_IsOK(res1)) {
46996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46997 }
46998 arg1 = reinterpret_cast< wxSizer * >(argp1);
46999 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47000 if (!SWIG_IsOK(res2)) {
47001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47002 }
47003 arg2 = reinterpret_cast< wxWindow * >(argp2);
47004 {
47005 PyThreadState* __tstate = wxPyBeginAllowThreads();
47006 (arg1)->SetVirtualSizeHints(arg2);
47007 wxPyEndAllowThreads(__tstate);
47008 if (PyErr_Occurred()) SWIG_fail;
47009 }
47010 resultobj = SWIG_Py_Void();
47011 return resultobj;
47012 fail:
47013 return NULL;
47014 }
47015
47016
47017 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47018 PyObject *resultobj = 0;
47019 wxSizer *arg1 = (wxSizer *) 0 ;
47020 bool arg2 = (bool) false ;
47021 void *argp1 = 0 ;
47022 int res1 = 0 ;
47023 bool val2 ;
47024 int ecode2 = 0 ;
47025 PyObject * obj0 = 0 ;
47026 PyObject * obj1 = 0 ;
47027 char * kwnames[] = {
47028 (char *) "self",(char *) "deleteWindows", NULL
47029 };
47030
47031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47033 if (!SWIG_IsOK(res1)) {
47034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47035 }
47036 arg1 = reinterpret_cast< wxSizer * >(argp1);
47037 if (obj1) {
47038 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47039 if (!SWIG_IsOK(ecode2)) {
47040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47041 }
47042 arg2 = static_cast< bool >(val2);
47043 }
47044 {
47045 PyThreadState* __tstate = wxPyBeginAllowThreads();
47046 (arg1)->Clear(arg2);
47047 wxPyEndAllowThreads(__tstate);
47048 if (PyErr_Occurred()) SWIG_fail;
47049 }
47050 resultobj = SWIG_Py_Void();
47051 return resultobj;
47052 fail:
47053 return NULL;
47054 }
47055
47056
47057 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47058 PyObject *resultobj = 0;
47059 wxSizer *arg1 = (wxSizer *) 0 ;
47060 void *argp1 = 0 ;
47061 int res1 = 0 ;
47062 PyObject *swig_obj[1] ;
47063
47064 if (!args) SWIG_fail;
47065 swig_obj[0] = args;
47066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47067 if (!SWIG_IsOK(res1)) {
47068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47069 }
47070 arg1 = reinterpret_cast< wxSizer * >(argp1);
47071 {
47072 PyThreadState* __tstate = wxPyBeginAllowThreads();
47073 (arg1)->DeleteWindows();
47074 wxPyEndAllowThreads(__tstate);
47075 if (PyErr_Occurred()) SWIG_fail;
47076 }
47077 resultobj = SWIG_Py_Void();
47078 return resultobj;
47079 fail:
47080 return NULL;
47081 }
47082
47083
47084 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47085 PyObject *resultobj = 0;
47086 wxSizer *arg1 = (wxSizer *) 0 ;
47087 PyObject *result = 0 ;
47088 void *argp1 = 0 ;
47089 int res1 = 0 ;
47090 PyObject *swig_obj[1] ;
47091
47092 if (!args) SWIG_fail;
47093 swig_obj[0] = args;
47094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47095 if (!SWIG_IsOK(res1)) {
47096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47097 }
47098 arg1 = reinterpret_cast< wxSizer * >(argp1);
47099 {
47100 PyThreadState* __tstate = wxPyBeginAllowThreads();
47101 result = (PyObject *)wxSizer_GetChildren(arg1);
47102 wxPyEndAllowThreads(__tstate);
47103 if (PyErr_Occurred()) SWIG_fail;
47104 }
47105 resultobj = result;
47106 return resultobj;
47107 fail:
47108 return NULL;
47109 }
47110
47111
47112 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47113 PyObject *resultobj = 0;
47114 wxSizer *arg1 = (wxSizer *) 0 ;
47115 PyObject *arg2 = (PyObject *) 0 ;
47116 bool arg3 = (bool) true ;
47117 bool arg4 = (bool) false ;
47118 bool result;
47119 void *argp1 = 0 ;
47120 int res1 = 0 ;
47121 bool val3 ;
47122 int ecode3 = 0 ;
47123 bool val4 ;
47124 int ecode4 = 0 ;
47125 PyObject * obj0 = 0 ;
47126 PyObject * obj1 = 0 ;
47127 PyObject * obj2 = 0 ;
47128 PyObject * obj3 = 0 ;
47129 char * kwnames[] = {
47130 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47131 };
47132
47133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47135 if (!SWIG_IsOK(res1)) {
47136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47137 }
47138 arg1 = reinterpret_cast< wxSizer * >(argp1);
47139 arg2 = obj1;
47140 if (obj2) {
47141 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47142 if (!SWIG_IsOK(ecode3)) {
47143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47144 }
47145 arg3 = static_cast< bool >(val3);
47146 }
47147 if (obj3) {
47148 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47149 if (!SWIG_IsOK(ecode4)) {
47150 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47151 }
47152 arg4 = static_cast< bool >(val4);
47153 }
47154 {
47155 PyThreadState* __tstate = wxPyBeginAllowThreads();
47156 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47157 wxPyEndAllowThreads(__tstate);
47158 if (PyErr_Occurred()) SWIG_fail;
47159 }
47160 {
47161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47162 }
47163 return resultobj;
47164 fail:
47165 return NULL;
47166 }
47167
47168
47169 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47170 PyObject *resultobj = 0;
47171 wxSizer *arg1 = (wxSizer *) 0 ;
47172 PyObject *arg2 = (PyObject *) 0 ;
47173 bool result;
47174 void *argp1 = 0 ;
47175 int res1 = 0 ;
47176 PyObject * obj0 = 0 ;
47177 PyObject * obj1 = 0 ;
47178 char * kwnames[] = {
47179 (char *) "self",(char *) "item", NULL
47180 };
47181
47182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47184 if (!SWIG_IsOK(res1)) {
47185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47186 }
47187 arg1 = reinterpret_cast< wxSizer * >(argp1);
47188 arg2 = obj1;
47189 {
47190 PyThreadState* __tstate = wxPyBeginAllowThreads();
47191 result = (bool)wxSizer_IsShown(arg1,arg2);
47192 wxPyEndAllowThreads(__tstate);
47193 if (PyErr_Occurred()) SWIG_fail;
47194 }
47195 {
47196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47197 }
47198 return resultobj;
47199 fail:
47200 return NULL;
47201 }
47202
47203
47204 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47205 PyObject *resultobj = 0;
47206 wxSizer *arg1 = (wxSizer *) 0 ;
47207 bool arg2 ;
47208 void *argp1 = 0 ;
47209 int res1 = 0 ;
47210 bool val2 ;
47211 int ecode2 = 0 ;
47212 PyObject * obj0 = 0 ;
47213 PyObject * obj1 = 0 ;
47214 char * kwnames[] = {
47215 (char *) "self",(char *) "show", NULL
47216 };
47217
47218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47220 if (!SWIG_IsOK(res1)) {
47221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47222 }
47223 arg1 = reinterpret_cast< wxSizer * >(argp1);
47224 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47225 if (!SWIG_IsOK(ecode2)) {
47226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47227 }
47228 arg2 = static_cast< bool >(val2);
47229 {
47230 PyThreadState* __tstate = wxPyBeginAllowThreads();
47231 (arg1)->ShowItems(arg2);
47232 wxPyEndAllowThreads(__tstate);
47233 if (PyErr_Occurred()) SWIG_fail;
47234 }
47235 resultobj = SWIG_Py_Void();
47236 return resultobj;
47237 fail:
47238 return NULL;
47239 }
47240
47241
47242 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47243 PyObject *obj;
47244 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47245 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47246 return SWIG_Py_Void();
47247 }
47248
47249 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47250 PyObject *resultobj = 0;
47251 wxPySizer *result = 0 ;
47252
47253 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47254 {
47255 PyThreadState* __tstate = wxPyBeginAllowThreads();
47256 result = (wxPySizer *)new wxPySizer();
47257 wxPyEndAllowThreads(__tstate);
47258 if (PyErr_Occurred()) SWIG_fail;
47259 }
47260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47261 return resultobj;
47262 fail:
47263 return NULL;
47264 }
47265
47266
47267 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47268 PyObject *resultobj = 0;
47269 wxPySizer *arg1 = (wxPySizer *) 0 ;
47270 PyObject *arg2 = (PyObject *) 0 ;
47271 PyObject *arg3 = (PyObject *) 0 ;
47272 void *argp1 = 0 ;
47273 int res1 = 0 ;
47274 PyObject * obj0 = 0 ;
47275 PyObject * obj1 = 0 ;
47276 PyObject * obj2 = 0 ;
47277 char * kwnames[] = {
47278 (char *) "self",(char *) "self",(char *) "_class", NULL
47279 };
47280
47281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47283 if (!SWIG_IsOK(res1)) {
47284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47285 }
47286 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47287 arg2 = obj1;
47288 arg3 = obj2;
47289 {
47290 PyThreadState* __tstate = wxPyBeginAllowThreads();
47291 (arg1)->_setCallbackInfo(arg2,arg3);
47292 wxPyEndAllowThreads(__tstate);
47293 if (PyErr_Occurred()) SWIG_fail;
47294 }
47295 resultobj = SWIG_Py_Void();
47296 return resultobj;
47297 fail:
47298 return NULL;
47299 }
47300
47301
47302 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47303 PyObject *obj;
47304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47305 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47306 return SWIG_Py_Void();
47307 }
47308
47309 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47310 return SWIG_Python_InitShadowInstance(args);
47311 }
47312
47313 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47314 PyObject *resultobj = 0;
47315 int arg1 = (int) wxHORIZONTAL ;
47316 wxBoxSizer *result = 0 ;
47317 int val1 ;
47318 int ecode1 = 0 ;
47319 PyObject * obj0 = 0 ;
47320 char * kwnames[] = {
47321 (char *) "orient", NULL
47322 };
47323
47324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47325 if (obj0) {
47326 ecode1 = SWIG_AsVal_int(obj0, &val1);
47327 if (!SWIG_IsOK(ecode1)) {
47328 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47329 }
47330 arg1 = static_cast< int >(val1);
47331 }
47332 {
47333 PyThreadState* __tstate = wxPyBeginAllowThreads();
47334 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47335 wxPyEndAllowThreads(__tstate);
47336 if (PyErr_Occurred()) SWIG_fail;
47337 }
47338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47339 return resultobj;
47340 fail:
47341 return NULL;
47342 }
47343
47344
47345 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47346 PyObject *resultobj = 0;
47347 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47348 int result;
47349 void *argp1 = 0 ;
47350 int res1 = 0 ;
47351 PyObject *swig_obj[1] ;
47352
47353 if (!args) SWIG_fail;
47354 swig_obj[0] = args;
47355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47356 if (!SWIG_IsOK(res1)) {
47357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47358 }
47359 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47360 {
47361 PyThreadState* __tstate = wxPyBeginAllowThreads();
47362 result = (int)(arg1)->GetOrientation();
47363 wxPyEndAllowThreads(__tstate);
47364 if (PyErr_Occurred()) SWIG_fail;
47365 }
47366 resultobj = SWIG_From_int(static_cast< int >(result));
47367 return resultobj;
47368 fail:
47369 return NULL;
47370 }
47371
47372
47373 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47374 PyObject *resultobj = 0;
47375 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47376 int arg2 ;
47377 void *argp1 = 0 ;
47378 int res1 = 0 ;
47379 int val2 ;
47380 int ecode2 = 0 ;
47381 PyObject * obj0 = 0 ;
47382 PyObject * obj1 = 0 ;
47383 char * kwnames[] = {
47384 (char *) "self",(char *) "orient", NULL
47385 };
47386
47387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47389 if (!SWIG_IsOK(res1)) {
47390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47391 }
47392 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47393 ecode2 = SWIG_AsVal_int(obj1, &val2);
47394 if (!SWIG_IsOK(ecode2)) {
47395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47396 }
47397 arg2 = static_cast< int >(val2);
47398 {
47399 PyThreadState* __tstate = wxPyBeginAllowThreads();
47400 (arg1)->SetOrientation(arg2);
47401 wxPyEndAllowThreads(__tstate);
47402 if (PyErr_Occurred()) SWIG_fail;
47403 }
47404 resultobj = SWIG_Py_Void();
47405 return resultobj;
47406 fail:
47407 return NULL;
47408 }
47409
47410
47411 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47412 PyObject *obj;
47413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47414 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47415 return SWIG_Py_Void();
47416 }
47417
47418 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47419 return SWIG_Python_InitShadowInstance(args);
47420 }
47421
47422 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47423 PyObject *resultobj = 0;
47424 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47425 int arg2 = (int) wxHORIZONTAL ;
47426 wxStaticBoxSizer *result = 0 ;
47427 void *argp1 = 0 ;
47428 int res1 = 0 ;
47429 int val2 ;
47430 int ecode2 = 0 ;
47431 PyObject * obj0 = 0 ;
47432 PyObject * obj1 = 0 ;
47433 char * kwnames[] = {
47434 (char *) "box",(char *) "orient", NULL
47435 };
47436
47437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47439 if (!SWIG_IsOK(res1)) {
47440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47441 }
47442 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47443 if (obj1) {
47444 ecode2 = SWIG_AsVal_int(obj1, &val2);
47445 if (!SWIG_IsOK(ecode2)) {
47446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47447 }
47448 arg2 = static_cast< int >(val2);
47449 }
47450 {
47451 PyThreadState* __tstate = wxPyBeginAllowThreads();
47452 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47453 wxPyEndAllowThreads(__tstate);
47454 if (PyErr_Occurred()) SWIG_fail;
47455 }
47456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47457 return resultobj;
47458 fail:
47459 return NULL;
47460 }
47461
47462
47463 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47464 PyObject *resultobj = 0;
47465 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47466 wxStaticBox *result = 0 ;
47467 void *argp1 = 0 ;
47468 int res1 = 0 ;
47469 PyObject *swig_obj[1] ;
47470
47471 if (!args) SWIG_fail;
47472 swig_obj[0] = args;
47473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47474 if (!SWIG_IsOK(res1)) {
47475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47476 }
47477 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47478 {
47479 PyThreadState* __tstate = wxPyBeginAllowThreads();
47480 result = (wxStaticBox *)(arg1)->GetStaticBox();
47481 wxPyEndAllowThreads(__tstate);
47482 if (PyErr_Occurred()) SWIG_fail;
47483 }
47484 {
47485 resultobj = wxPyMake_wxObject(result, (bool)0);
47486 }
47487 return resultobj;
47488 fail:
47489 return NULL;
47490 }
47491
47492
47493 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47494 PyObject *obj;
47495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47496 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47497 return SWIG_Py_Void();
47498 }
47499
47500 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47501 return SWIG_Python_InitShadowInstance(args);
47502 }
47503
47504 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47505 PyObject *resultobj = 0;
47506 int arg1 = (int) 1 ;
47507 int arg2 = (int) 0 ;
47508 int arg3 = (int) 0 ;
47509 int arg4 = (int) 0 ;
47510 wxGridSizer *result = 0 ;
47511 int val1 ;
47512 int ecode1 = 0 ;
47513 int val2 ;
47514 int ecode2 = 0 ;
47515 int val3 ;
47516 int ecode3 = 0 ;
47517 int val4 ;
47518 int ecode4 = 0 ;
47519 PyObject * obj0 = 0 ;
47520 PyObject * obj1 = 0 ;
47521 PyObject * obj2 = 0 ;
47522 PyObject * obj3 = 0 ;
47523 char * kwnames[] = {
47524 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47525 };
47526
47527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47528 if (obj0) {
47529 ecode1 = SWIG_AsVal_int(obj0, &val1);
47530 if (!SWIG_IsOK(ecode1)) {
47531 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47532 }
47533 arg1 = static_cast< int >(val1);
47534 }
47535 if (obj1) {
47536 ecode2 = SWIG_AsVal_int(obj1, &val2);
47537 if (!SWIG_IsOK(ecode2)) {
47538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47539 }
47540 arg2 = static_cast< int >(val2);
47541 }
47542 if (obj2) {
47543 ecode3 = SWIG_AsVal_int(obj2, &val3);
47544 if (!SWIG_IsOK(ecode3)) {
47545 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47546 }
47547 arg3 = static_cast< int >(val3);
47548 }
47549 if (obj3) {
47550 ecode4 = SWIG_AsVal_int(obj3, &val4);
47551 if (!SWIG_IsOK(ecode4)) {
47552 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47553 }
47554 arg4 = static_cast< int >(val4);
47555 }
47556 {
47557 PyThreadState* __tstate = wxPyBeginAllowThreads();
47558 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47559 wxPyEndAllowThreads(__tstate);
47560 if (PyErr_Occurred()) SWIG_fail;
47561 }
47562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47563 return resultobj;
47564 fail:
47565 return NULL;
47566 }
47567
47568
47569 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47570 PyObject *resultobj = 0;
47571 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47572 int arg2 ;
47573 void *argp1 = 0 ;
47574 int res1 = 0 ;
47575 int val2 ;
47576 int ecode2 = 0 ;
47577 PyObject * obj0 = 0 ;
47578 PyObject * obj1 = 0 ;
47579 char * kwnames[] = {
47580 (char *) "self",(char *) "cols", NULL
47581 };
47582
47583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47585 if (!SWIG_IsOK(res1)) {
47586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47587 }
47588 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47589 ecode2 = SWIG_AsVal_int(obj1, &val2);
47590 if (!SWIG_IsOK(ecode2)) {
47591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47592 }
47593 arg2 = static_cast< int >(val2);
47594 {
47595 PyThreadState* __tstate = wxPyBeginAllowThreads();
47596 (arg1)->SetCols(arg2);
47597 wxPyEndAllowThreads(__tstate);
47598 if (PyErr_Occurred()) SWIG_fail;
47599 }
47600 resultobj = SWIG_Py_Void();
47601 return resultobj;
47602 fail:
47603 return NULL;
47604 }
47605
47606
47607 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47608 PyObject *resultobj = 0;
47609 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47610 int arg2 ;
47611 void *argp1 = 0 ;
47612 int res1 = 0 ;
47613 int val2 ;
47614 int ecode2 = 0 ;
47615 PyObject * obj0 = 0 ;
47616 PyObject * obj1 = 0 ;
47617 char * kwnames[] = {
47618 (char *) "self",(char *) "rows", NULL
47619 };
47620
47621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47623 if (!SWIG_IsOK(res1)) {
47624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47625 }
47626 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47627 ecode2 = SWIG_AsVal_int(obj1, &val2);
47628 if (!SWIG_IsOK(ecode2)) {
47629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47630 }
47631 arg2 = static_cast< int >(val2);
47632 {
47633 PyThreadState* __tstate = wxPyBeginAllowThreads();
47634 (arg1)->SetRows(arg2);
47635 wxPyEndAllowThreads(__tstate);
47636 if (PyErr_Occurred()) SWIG_fail;
47637 }
47638 resultobj = SWIG_Py_Void();
47639 return resultobj;
47640 fail:
47641 return NULL;
47642 }
47643
47644
47645 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47646 PyObject *resultobj = 0;
47647 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47648 int arg2 ;
47649 void *argp1 = 0 ;
47650 int res1 = 0 ;
47651 int val2 ;
47652 int ecode2 = 0 ;
47653 PyObject * obj0 = 0 ;
47654 PyObject * obj1 = 0 ;
47655 char * kwnames[] = {
47656 (char *) "self",(char *) "gap", NULL
47657 };
47658
47659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47661 if (!SWIG_IsOK(res1)) {
47662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47663 }
47664 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47665 ecode2 = SWIG_AsVal_int(obj1, &val2);
47666 if (!SWIG_IsOK(ecode2)) {
47667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47668 }
47669 arg2 = static_cast< int >(val2);
47670 {
47671 PyThreadState* __tstate = wxPyBeginAllowThreads();
47672 (arg1)->SetVGap(arg2);
47673 wxPyEndAllowThreads(__tstate);
47674 if (PyErr_Occurred()) SWIG_fail;
47675 }
47676 resultobj = SWIG_Py_Void();
47677 return resultobj;
47678 fail:
47679 return NULL;
47680 }
47681
47682
47683 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47684 PyObject *resultobj = 0;
47685 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47686 int arg2 ;
47687 void *argp1 = 0 ;
47688 int res1 = 0 ;
47689 int val2 ;
47690 int ecode2 = 0 ;
47691 PyObject * obj0 = 0 ;
47692 PyObject * obj1 = 0 ;
47693 char * kwnames[] = {
47694 (char *) "self",(char *) "gap", NULL
47695 };
47696
47697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47699 if (!SWIG_IsOK(res1)) {
47700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47701 }
47702 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47703 ecode2 = SWIG_AsVal_int(obj1, &val2);
47704 if (!SWIG_IsOK(ecode2)) {
47705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47706 }
47707 arg2 = static_cast< int >(val2);
47708 {
47709 PyThreadState* __tstate = wxPyBeginAllowThreads();
47710 (arg1)->SetHGap(arg2);
47711 wxPyEndAllowThreads(__tstate);
47712 if (PyErr_Occurred()) SWIG_fail;
47713 }
47714 resultobj = SWIG_Py_Void();
47715 return resultobj;
47716 fail:
47717 return NULL;
47718 }
47719
47720
47721 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47722 PyObject *resultobj = 0;
47723 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47724 int result;
47725 void *argp1 = 0 ;
47726 int res1 = 0 ;
47727 PyObject *swig_obj[1] ;
47728
47729 if (!args) SWIG_fail;
47730 swig_obj[0] = args;
47731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47732 if (!SWIG_IsOK(res1)) {
47733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47734 }
47735 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47736 {
47737 PyThreadState* __tstate = wxPyBeginAllowThreads();
47738 result = (int)(arg1)->GetCols();
47739 wxPyEndAllowThreads(__tstate);
47740 if (PyErr_Occurred()) SWIG_fail;
47741 }
47742 resultobj = SWIG_From_int(static_cast< int >(result));
47743 return resultobj;
47744 fail:
47745 return NULL;
47746 }
47747
47748
47749 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47750 PyObject *resultobj = 0;
47751 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47752 int result;
47753 void *argp1 = 0 ;
47754 int res1 = 0 ;
47755 PyObject *swig_obj[1] ;
47756
47757 if (!args) SWIG_fail;
47758 swig_obj[0] = args;
47759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47760 if (!SWIG_IsOK(res1)) {
47761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47762 }
47763 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47764 {
47765 PyThreadState* __tstate = wxPyBeginAllowThreads();
47766 result = (int)(arg1)->GetRows();
47767 wxPyEndAllowThreads(__tstate);
47768 if (PyErr_Occurred()) SWIG_fail;
47769 }
47770 resultobj = SWIG_From_int(static_cast< int >(result));
47771 return resultobj;
47772 fail:
47773 return NULL;
47774 }
47775
47776
47777 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47778 PyObject *resultobj = 0;
47779 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47780 int result;
47781 void *argp1 = 0 ;
47782 int res1 = 0 ;
47783 PyObject *swig_obj[1] ;
47784
47785 if (!args) SWIG_fail;
47786 swig_obj[0] = args;
47787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47788 if (!SWIG_IsOK(res1)) {
47789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47790 }
47791 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47792 {
47793 PyThreadState* __tstate = wxPyBeginAllowThreads();
47794 result = (int)(arg1)->GetVGap();
47795 wxPyEndAllowThreads(__tstate);
47796 if (PyErr_Occurred()) SWIG_fail;
47797 }
47798 resultobj = SWIG_From_int(static_cast< int >(result));
47799 return resultobj;
47800 fail:
47801 return NULL;
47802 }
47803
47804
47805 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47806 PyObject *resultobj = 0;
47807 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47808 int result;
47809 void *argp1 = 0 ;
47810 int res1 = 0 ;
47811 PyObject *swig_obj[1] ;
47812
47813 if (!args) SWIG_fail;
47814 swig_obj[0] = args;
47815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47816 if (!SWIG_IsOK(res1)) {
47817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47818 }
47819 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47820 {
47821 PyThreadState* __tstate = wxPyBeginAllowThreads();
47822 result = (int)(arg1)->GetHGap();
47823 wxPyEndAllowThreads(__tstate);
47824 if (PyErr_Occurred()) SWIG_fail;
47825 }
47826 resultobj = SWIG_From_int(static_cast< int >(result));
47827 return resultobj;
47828 fail:
47829 return NULL;
47830 }
47831
47832
47833 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47834 PyObject *obj;
47835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47836 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47837 return SWIG_Py_Void();
47838 }
47839
47840 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47841 return SWIG_Python_InitShadowInstance(args);
47842 }
47843
47844 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47845 PyObject *resultobj = 0;
47846 int arg1 = (int) 1 ;
47847 int arg2 = (int) 0 ;
47848 int arg3 = (int) 0 ;
47849 int arg4 = (int) 0 ;
47850 wxFlexGridSizer *result = 0 ;
47851 int val1 ;
47852 int ecode1 = 0 ;
47853 int val2 ;
47854 int ecode2 = 0 ;
47855 int val3 ;
47856 int ecode3 = 0 ;
47857 int val4 ;
47858 int ecode4 = 0 ;
47859 PyObject * obj0 = 0 ;
47860 PyObject * obj1 = 0 ;
47861 PyObject * obj2 = 0 ;
47862 PyObject * obj3 = 0 ;
47863 char * kwnames[] = {
47864 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47865 };
47866
47867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47868 if (obj0) {
47869 ecode1 = SWIG_AsVal_int(obj0, &val1);
47870 if (!SWIG_IsOK(ecode1)) {
47871 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47872 }
47873 arg1 = static_cast< int >(val1);
47874 }
47875 if (obj1) {
47876 ecode2 = SWIG_AsVal_int(obj1, &val2);
47877 if (!SWIG_IsOK(ecode2)) {
47878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47879 }
47880 arg2 = static_cast< int >(val2);
47881 }
47882 if (obj2) {
47883 ecode3 = SWIG_AsVal_int(obj2, &val3);
47884 if (!SWIG_IsOK(ecode3)) {
47885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47886 }
47887 arg3 = static_cast< int >(val3);
47888 }
47889 if (obj3) {
47890 ecode4 = SWIG_AsVal_int(obj3, &val4);
47891 if (!SWIG_IsOK(ecode4)) {
47892 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47893 }
47894 arg4 = static_cast< int >(val4);
47895 }
47896 {
47897 PyThreadState* __tstate = wxPyBeginAllowThreads();
47898 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47899 wxPyEndAllowThreads(__tstate);
47900 if (PyErr_Occurred()) SWIG_fail;
47901 }
47902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47903 return resultobj;
47904 fail:
47905 return NULL;
47906 }
47907
47908
47909 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47910 PyObject *resultobj = 0;
47911 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47912 size_t arg2 ;
47913 int arg3 = (int) 0 ;
47914 void *argp1 = 0 ;
47915 int res1 = 0 ;
47916 size_t val2 ;
47917 int ecode2 = 0 ;
47918 int val3 ;
47919 int ecode3 = 0 ;
47920 PyObject * obj0 = 0 ;
47921 PyObject * obj1 = 0 ;
47922 PyObject * obj2 = 0 ;
47923 char * kwnames[] = {
47924 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47925 };
47926
47927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47929 if (!SWIG_IsOK(res1)) {
47930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47931 }
47932 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47933 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47934 if (!SWIG_IsOK(ecode2)) {
47935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47936 }
47937 arg2 = static_cast< size_t >(val2);
47938 if (obj2) {
47939 ecode3 = SWIG_AsVal_int(obj2, &val3);
47940 if (!SWIG_IsOK(ecode3)) {
47941 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47942 }
47943 arg3 = static_cast< int >(val3);
47944 }
47945 {
47946 PyThreadState* __tstate = wxPyBeginAllowThreads();
47947 (arg1)->AddGrowableRow(arg2,arg3);
47948 wxPyEndAllowThreads(__tstate);
47949 if (PyErr_Occurred()) SWIG_fail;
47950 }
47951 resultobj = SWIG_Py_Void();
47952 return resultobj;
47953 fail:
47954 return NULL;
47955 }
47956
47957
47958 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47959 PyObject *resultobj = 0;
47960 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47961 size_t arg2 ;
47962 void *argp1 = 0 ;
47963 int res1 = 0 ;
47964 size_t val2 ;
47965 int ecode2 = 0 ;
47966 PyObject * obj0 = 0 ;
47967 PyObject * obj1 = 0 ;
47968 char * kwnames[] = {
47969 (char *) "self",(char *) "idx", NULL
47970 };
47971
47972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47974 if (!SWIG_IsOK(res1)) {
47975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47976 }
47977 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47978 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47979 if (!SWIG_IsOK(ecode2)) {
47980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47981 }
47982 arg2 = static_cast< size_t >(val2);
47983 {
47984 PyThreadState* __tstate = wxPyBeginAllowThreads();
47985 (arg1)->RemoveGrowableRow(arg2);
47986 wxPyEndAllowThreads(__tstate);
47987 if (PyErr_Occurred()) SWIG_fail;
47988 }
47989 resultobj = SWIG_Py_Void();
47990 return resultobj;
47991 fail:
47992 return NULL;
47993 }
47994
47995
47996 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47997 PyObject *resultobj = 0;
47998 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47999 size_t arg2 ;
48000 int arg3 = (int) 0 ;
48001 void *argp1 = 0 ;
48002 int res1 = 0 ;
48003 size_t val2 ;
48004 int ecode2 = 0 ;
48005 int val3 ;
48006 int ecode3 = 0 ;
48007 PyObject * obj0 = 0 ;
48008 PyObject * obj1 = 0 ;
48009 PyObject * obj2 = 0 ;
48010 char * kwnames[] = {
48011 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48012 };
48013
48014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48016 if (!SWIG_IsOK(res1)) {
48017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48018 }
48019 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48020 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48021 if (!SWIG_IsOK(ecode2)) {
48022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48023 }
48024 arg2 = static_cast< size_t >(val2);
48025 if (obj2) {
48026 ecode3 = SWIG_AsVal_int(obj2, &val3);
48027 if (!SWIG_IsOK(ecode3)) {
48028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48029 }
48030 arg3 = static_cast< int >(val3);
48031 }
48032 {
48033 PyThreadState* __tstate = wxPyBeginAllowThreads();
48034 (arg1)->AddGrowableCol(arg2,arg3);
48035 wxPyEndAllowThreads(__tstate);
48036 if (PyErr_Occurred()) SWIG_fail;
48037 }
48038 resultobj = SWIG_Py_Void();
48039 return resultobj;
48040 fail:
48041 return NULL;
48042 }
48043
48044
48045 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48046 PyObject *resultobj = 0;
48047 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48048 size_t arg2 ;
48049 void *argp1 = 0 ;
48050 int res1 = 0 ;
48051 size_t val2 ;
48052 int ecode2 = 0 ;
48053 PyObject * obj0 = 0 ;
48054 PyObject * obj1 = 0 ;
48055 char * kwnames[] = {
48056 (char *) "self",(char *) "idx", NULL
48057 };
48058
48059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48061 if (!SWIG_IsOK(res1)) {
48062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48063 }
48064 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48065 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48066 if (!SWIG_IsOK(ecode2)) {
48067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48068 }
48069 arg2 = static_cast< size_t >(val2);
48070 {
48071 PyThreadState* __tstate = wxPyBeginAllowThreads();
48072 (arg1)->RemoveGrowableCol(arg2);
48073 wxPyEndAllowThreads(__tstate);
48074 if (PyErr_Occurred()) SWIG_fail;
48075 }
48076 resultobj = SWIG_Py_Void();
48077 return resultobj;
48078 fail:
48079 return NULL;
48080 }
48081
48082
48083 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48084 PyObject *resultobj = 0;
48085 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48086 int arg2 ;
48087 void *argp1 = 0 ;
48088 int res1 = 0 ;
48089 int val2 ;
48090 int ecode2 = 0 ;
48091 PyObject * obj0 = 0 ;
48092 PyObject * obj1 = 0 ;
48093 char * kwnames[] = {
48094 (char *) "self",(char *) "direction", NULL
48095 };
48096
48097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48099 if (!SWIG_IsOK(res1)) {
48100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48101 }
48102 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48103 ecode2 = SWIG_AsVal_int(obj1, &val2);
48104 if (!SWIG_IsOK(ecode2)) {
48105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48106 }
48107 arg2 = static_cast< int >(val2);
48108 {
48109 PyThreadState* __tstate = wxPyBeginAllowThreads();
48110 (arg1)->SetFlexibleDirection(arg2);
48111 wxPyEndAllowThreads(__tstate);
48112 if (PyErr_Occurred()) SWIG_fail;
48113 }
48114 resultobj = SWIG_Py_Void();
48115 return resultobj;
48116 fail:
48117 return NULL;
48118 }
48119
48120
48121 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48122 PyObject *resultobj = 0;
48123 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48124 int result;
48125 void *argp1 = 0 ;
48126 int res1 = 0 ;
48127 PyObject *swig_obj[1] ;
48128
48129 if (!args) SWIG_fail;
48130 swig_obj[0] = args;
48131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48132 if (!SWIG_IsOK(res1)) {
48133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48134 }
48135 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48136 {
48137 PyThreadState* __tstate = wxPyBeginAllowThreads();
48138 result = (int)(arg1)->GetFlexibleDirection();
48139 wxPyEndAllowThreads(__tstate);
48140 if (PyErr_Occurred()) SWIG_fail;
48141 }
48142 resultobj = SWIG_From_int(static_cast< int >(result));
48143 return resultobj;
48144 fail:
48145 return NULL;
48146 }
48147
48148
48149 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48150 PyObject *resultobj = 0;
48151 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48152 wxFlexSizerGrowMode arg2 ;
48153 void *argp1 = 0 ;
48154 int res1 = 0 ;
48155 int val2 ;
48156 int ecode2 = 0 ;
48157 PyObject * obj0 = 0 ;
48158 PyObject * obj1 = 0 ;
48159 char * kwnames[] = {
48160 (char *) "self",(char *) "mode", NULL
48161 };
48162
48163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48165 if (!SWIG_IsOK(res1)) {
48166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48167 }
48168 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48169 ecode2 = SWIG_AsVal_int(obj1, &val2);
48170 if (!SWIG_IsOK(ecode2)) {
48171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48172 }
48173 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48174 {
48175 PyThreadState* __tstate = wxPyBeginAllowThreads();
48176 (arg1)->SetNonFlexibleGrowMode(arg2);
48177 wxPyEndAllowThreads(__tstate);
48178 if (PyErr_Occurred()) SWIG_fail;
48179 }
48180 resultobj = SWIG_Py_Void();
48181 return resultobj;
48182 fail:
48183 return NULL;
48184 }
48185
48186
48187 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48188 PyObject *resultobj = 0;
48189 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48190 wxFlexSizerGrowMode result;
48191 void *argp1 = 0 ;
48192 int res1 = 0 ;
48193 PyObject *swig_obj[1] ;
48194
48195 if (!args) SWIG_fail;
48196 swig_obj[0] = args;
48197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48198 if (!SWIG_IsOK(res1)) {
48199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48200 }
48201 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48202 {
48203 PyThreadState* __tstate = wxPyBeginAllowThreads();
48204 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48205 wxPyEndAllowThreads(__tstate);
48206 if (PyErr_Occurred()) SWIG_fail;
48207 }
48208 resultobj = SWIG_From_int(static_cast< int >(result));
48209 return resultobj;
48210 fail:
48211 return NULL;
48212 }
48213
48214
48215 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48216 PyObject *resultobj = 0;
48217 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48218 wxArrayInt *result = 0 ;
48219 void *argp1 = 0 ;
48220 int res1 = 0 ;
48221 PyObject *swig_obj[1] ;
48222
48223 if (!args) SWIG_fail;
48224 swig_obj[0] = args;
48225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48226 if (!SWIG_IsOK(res1)) {
48227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48228 }
48229 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48230 {
48231 PyThreadState* __tstate = wxPyBeginAllowThreads();
48232 {
48233 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48234 result = (wxArrayInt *) &_result_ref;
48235 }
48236 wxPyEndAllowThreads(__tstate);
48237 if (PyErr_Occurred()) SWIG_fail;
48238 }
48239 {
48240 resultobj = PyList_New(0);
48241 size_t idx;
48242 for (idx = 0; idx < result->GetCount(); idx += 1) {
48243 PyObject* val = PyInt_FromLong( result->Item(idx) );
48244 PyList_Append(resultobj, val);
48245 Py_DECREF(val);
48246 }
48247 }
48248 return resultobj;
48249 fail:
48250 return NULL;
48251 }
48252
48253
48254 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48255 PyObject *resultobj = 0;
48256 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48257 wxArrayInt *result = 0 ;
48258 void *argp1 = 0 ;
48259 int res1 = 0 ;
48260 PyObject *swig_obj[1] ;
48261
48262 if (!args) SWIG_fail;
48263 swig_obj[0] = args;
48264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48265 if (!SWIG_IsOK(res1)) {
48266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48267 }
48268 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48269 {
48270 PyThreadState* __tstate = wxPyBeginAllowThreads();
48271 {
48272 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48273 result = (wxArrayInt *) &_result_ref;
48274 }
48275 wxPyEndAllowThreads(__tstate);
48276 if (PyErr_Occurred()) SWIG_fail;
48277 }
48278 {
48279 resultobj = PyList_New(0);
48280 size_t idx;
48281 for (idx = 0; idx < result->GetCount(); idx += 1) {
48282 PyObject* val = PyInt_FromLong( result->Item(idx) );
48283 PyList_Append(resultobj, val);
48284 Py_DECREF(val);
48285 }
48286 }
48287 return resultobj;
48288 fail:
48289 return NULL;
48290 }
48291
48292
48293 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48294 PyObject *obj;
48295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48296 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48297 return SWIG_Py_Void();
48298 }
48299
48300 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48301 return SWIG_Python_InitShadowInstance(args);
48302 }
48303
48304 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48305 PyObject *resultobj = 0;
48306 wxStdDialogButtonSizer *result = 0 ;
48307
48308 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48309 {
48310 PyThreadState* __tstate = wxPyBeginAllowThreads();
48311 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48312 wxPyEndAllowThreads(__tstate);
48313 if (PyErr_Occurred()) SWIG_fail;
48314 }
48315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48316 return resultobj;
48317 fail:
48318 return NULL;
48319 }
48320
48321
48322 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48323 PyObject *resultobj = 0;
48324 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48325 wxButton *arg2 = (wxButton *) 0 ;
48326 void *argp1 = 0 ;
48327 int res1 = 0 ;
48328 void *argp2 = 0 ;
48329 int res2 = 0 ;
48330 PyObject * obj0 = 0 ;
48331 PyObject * obj1 = 0 ;
48332 char * kwnames[] = {
48333 (char *) "self",(char *) "button", NULL
48334 };
48335
48336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48338 if (!SWIG_IsOK(res1)) {
48339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48340 }
48341 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48342 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48343 if (!SWIG_IsOK(res2)) {
48344 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48345 }
48346 arg2 = reinterpret_cast< wxButton * >(argp2);
48347 {
48348 PyThreadState* __tstate = wxPyBeginAllowThreads();
48349 (arg1)->AddButton(arg2);
48350 wxPyEndAllowThreads(__tstate);
48351 if (PyErr_Occurred()) SWIG_fail;
48352 }
48353 resultobj = SWIG_Py_Void();
48354 return resultobj;
48355 fail:
48356 return NULL;
48357 }
48358
48359
48360 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48361 PyObject *resultobj = 0;
48362 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48363 void *argp1 = 0 ;
48364 int res1 = 0 ;
48365 PyObject *swig_obj[1] ;
48366
48367 if (!args) SWIG_fail;
48368 swig_obj[0] = args;
48369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48370 if (!SWIG_IsOK(res1)) {
48371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48372 }
48373 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48374 {
48375 PyThreadState* __tstate = wxPyBeginAllowThreads();
48376 (arg1)->Realize();
48377 wxPyEndAllowThreads(__tstate);
48378 if (PyErr_Occurred()) SWIG_fail;
48379 }
48380 resultobj = SWIG_Py_Void();
48381 return resultobj;
48382 fail:
48383 return NULL;
48384 }
48385
48386
48387 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48388 PyObject *resultobj = 0;
48389 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48390 wxButton *arg2 = (wxButton *) 0 ;
48391 void *argp1 = 0 ;
48392 int res1 = 0 ;
48393 void *argp2 = 0 ;
48394 int res2 = 0 ;
48395 PyObject * obj0 = 0 ;
48396 PyObject * obj1 = 0 ;
48397 char * kwnames[] = {
48398 (char *) "self",(char *) "button", NULL
48399 };
48400
48401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48403 if (!SWIG_IsOK(res1)) {
48404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48405 }
48406 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48407 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48408 if (!SWIG_IsOK(res2)) {
48409 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48410 }
48411 arg2 = reinterpret_cast< wxButton * >(argp2);
48412 {
48413 PyThreadState* __tstate = wxPyBeginAllowThreads();
48414 (arg1)->SetAffirmativeButton(arg2);
48415 wxPyEndAllowThreads(__tstate);
48416 if (PyErr_Occurred()) SWIG_fail;
48417 }
48418 resultobj = SWIG_Py_Void();
48419 return resultobj;
48420 fail:
48421 return NULL;
48422 }
48423
48424
48425 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48426 PyObject *resultobj = 0;
48427 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48428 wxButton *arg2 = (wxButton *) 0 ;
48429 void *argp1 = 0 ;
48430 int res1 = 0 ;
48431 void *argp2 = 0 ;
48432 int res2 = 0 ;
48433 PyObject * obj0 = 0 ;
48434 PyObject * obj1 = 0 ;
48435 char * kwnames[] = {
48436 (char *) "self",(char *) "button", NULL
48437 };
48438
48439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48441 if (!SWIG_IsOK(res1)) {
48442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48443 }
48444 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48445 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48446 if (!SWIG_IsOK(res2)) {
48447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48448 }
48449 arg2 = reinterpret_cast< wxButton * >(argp2);
48450 {
48451 PyThreadState* __tstate = wxPyBeginAllowThreads();
48452 (arg1)->SetNegativeButton(arg2);
48453 wxPyEndAllowThreads(__tstate);
48454 if (PyErr_Occurred()) SWIG_fail;
48455 }
48456 resultobj = SWIG_Py_Void();
48457 return resultobj;
48458 fail:
48459 return NULL;
48460 }
48461
48462
48463 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48464 PyObject *resultobj = 0;
48465 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48466 wxButton *arg2 = (wxButton *) 0 ;
48467 void *argp1 = 0 ;
48468 int res1 = 0 ;
48469 void *argp2 = 0 ;
48470 int res2 = 0 ;
48471 PyObject * obj0 = 0 ;
48472 PyObject * obj1 = 0 ;
48473 char * kwnames[] = {
48474 (char *) "self",(char *) "button", NULL
48475 };
48476
48477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48479 if (!SWIG_IsOK(res1)) {
48480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48481 }
48482 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48483 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48484 if (!SWIG_IsOK(res2)) {
48485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48486 }
48487 arg2 = reinterpret_cast< wxButton * >(argp2);
48488 {
48489 PyThreadState* __tstate = wxPyBeginAllowThreads();
48490 (arg1)->SetCancelButton(arg2);
48491 wxPyEndAllowThreads(__tstate);
48492 if (PyErr_Occurred()) SWIG_fail;
48493 }
48494 resultobj = SWIG_Py_Void();
48495 return resultobj;
48496 fail:
48497 return NULL;
48498 }
48499
48500
48501 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48502 PyObject *resultobj = 0;
48503 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48504 wxButton *result = 0 ;
48505 void *argp1 = 0 ;
48506 int res1 = 0 ;
48507 PyObject *swig_obj[1] ;
48508
48509 if (!args) SWIG_fail;
48510 swig_obj[0] = args;
48511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48512 if (!SWIG_IsOK(res1)) {
48513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48514 }
48515 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48516 {
48517 PyThreadState* __tstate = wxPyBeginAllowThreads();
48518 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48519 wxPyEndAllowThreads(__tstate);
48520 if (PyErr_Occurred()) SWIG_fail;
48521 }
48522 {
48523 resultobj = wxPyMake_wxObject(result, (bool)0);
48524 }
48525 return resultobj;
48526 fail:
48527 return NULL;
48528 }
48529
48530
48531 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48532 PyObject *resultobj = 0;
48533 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48534 wxButton *result = 0 ;
48535 void *argp1 = 0 ;
48536 int res1 = 0 ;
48537 PyObject *swig_obj[1] ;
48538
48539 if (!args) SWIG_fail;
48540 swig_obj[0] = args;
48541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48542 if (!SWIG_IsOK(res1)) {
48543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48544 }
48545 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48546 {
48547 PyThreadState* __tstate = wxPyBeginAllowThreads();
48548 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48549 wxPyEndAllowThreads(__tstate);
48550 if (PyErr_Occurred()) SWIG_fail;
48551 }
48552 {
48553 resultobj = wxPyMake_wxObject(result, (bool)0);
48554 }
48555 return resultobj;
48556 fail:
48557 return NULL;
48558 }
48559
48560
48561 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48562 PyObject *resultobj = 0;
48563 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48564 wxButton *result = 0 ;
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_wxStdDialogButtonSizer, 0 | 0 );
48572 if (!SWIG_IsOK(res1)) {
48573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48574 }
48575 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48576 {
48577 PyThreadState* __tstate = wxPyBeginAllowThreads();
48578 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48579 wxPyEndAllowThreads(__tstate);
48580 if (PyErr_Occurred()) SWIG_fail;
48581 }
48582 {
48583 resultobj = wxPyMake_wxObject(result, (bool)0);
48584 }
48585 return resultobj;
48586 fail:
48587 return NULL;
48588 }
48589
48590
48591 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48592 PyObject *resultobj = 0;
48593 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48594 wxButton *result = 0 ;
48595 void *argp1 = 0 ;
48596 int res1 = 0 ;
48597 PyObject *swig_obj[1] ;
48598
48599 if (!args) SWIG_fail;
48600 swig_obj[0] = args;
48601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48602 if (!SWIG_IsOK(res1)) {
48603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48604 }
48605 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48606 {
48607 PyThreadState* __tstate = wxPyBeginAllowThreads();
48608 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48609 wxPyEndAllowThreads(__tstate);
48610 if (PyErr_Occurred()) SWIG_fail;
48611 }
48612 {
48613 resultobj = wxPyMake_wxObject(result, (bool)0);
48614 }
48615 return resultobj;
48616 fail:
48617 return NULL;
48618 }
48619
48620
48621 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48622 PyObject *resultobj = 0;
48623 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48624 wxButton *result = 0 ;
48625 void *argp1 = 0 ;
48626 int res1 = 0 ;
48627 PyObject *swig_obj[1] ;
48628
48629 if (!args) SWIG_fail;
48630 swig_obj[0] = args;
48631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48632 if (!SWIG_IsOK(res1)) {
48633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48634 }
48635 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48636 {
48637 PyThreadState* __tstate = wxPyBeginAllowThreads();
48638 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48639 wxPyEndAllowThreads(__tstate);
48640 if (PyErr_Occurred()) SWIG_fail;
48641 }
48642 {
48643 resultobj = wxPyMake_wxObject(result, (bool)0);
48644 }
48645 return resultobj;
48646 fail:
48647 return NULL;
48648 }
48649
48650
48651 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48652 PyObject *obj;
48653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48654 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48655 return SWIG_Py_Void();
48656 }
48657
48658 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48659 return SWIG_Python_InitShadowInstance(args);
48660 }
48661
48662 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48663 PyObject *resultobj = 0;
48664 int arg1 = (int) 0 ;
48665 int arg2 = (int) 0 ;
48666 wxGBPosition *result = 0 ;
48667 int val1 ;
48668 int ecode1 = 0 ;
48669 int val2 ;
48670 int ecode2 = 0 ;
48671 PyObject * obj0 = 0 ;
48672 PyObject * obj1 = 0 ;
48673 char * kwnames[] = {
48674 (char *) "row",(char *) "col", NULL
48675 };
48676
48677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48678 if (obj0) {
48679 ecode1 = SWIG_AsVal_int(obj0, &val1);
48680 if (!SWIG_IsOK(ecode1)) {
48681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48682 }
48683 arg1 = static_cast< int >(val1);
48684 }
48685 if (obj1) {
48686 ecode2 = SWIG_AsVal_int(obj1, &val2);
48687 if (!SWIG_IsOK(ecode2)) {
48688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48689 }
48690 arg2 = static_cast< int >(val2);
48691 }
48692 {
48693 PyThreadState* __tstate = wxPyBeginAllowThreads();
48694 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48695 wxPyEndAllowThreads(__tstate);
48696 if (PyErr_Occurred()) SWIG_fail;
48697 }
48698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48699 return resultobj;
48700 fail:
48701 return NULL;
48702 }
48703
48704
48705 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48706 PyObject *resultobj = 0;
48707 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48708 void *argp1 = 0 ;
48709 int res1 = 0 ;
48710 PyObject *swig_obj[1] ;
48711
48712 if (!args) SWIG_fail;
48713 swig_obj[0] = args;
48714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48715 if (!SWIG_IsOK(res1)) {
48716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48717 }
48718 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48719 {
48720 PyThreadState* __tstate = wxPyBeginAllowThreads();
48721 delete arg1;
48722
48723 wxPyEndAllowThreads(__tstate);
48724 if (PyErr_Occurred()) SWIG_fail;
48725 }
48726 resultobj = SWIG_Py_Void();
48727 return resultobj;
48728 fail:
48729 return NULL;
48730 }
48731
48732
48733 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48734 PyObject *resultobj = 0;
48735 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48736 int result;
48737 void *argp1 = 0 ;
48738 int res1 = 0 ;
48739 PyObject *swig_obj[1] ;
48740
48741 if (!args) SWIG_fail;
48742 swig_obj[0] = args;
48743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48744 if (!SWIG_IsOK(res1)) {
48745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48746 }
48747 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48748 {
48749 PyThreadState* __tstate = wxPyBeginAllowThreads();
48750 result = (int)((wxGBPosition const *)arg1)->GetRow();
48751 wxPyEndAllowThreads(__tstate);
48752 if (PyErr_Occurred()) SWIG_fail;
48753 }
48754 resultobj = SWIG_From_int(static_cast< int >(result));
48755 return resultobj;
48756 fail:
48757 return NULL;
48758 }
48759
48760
48761 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48762 PyObject *resultobj = 0;
48763 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48764 int result;
48765 void *argp1 = 0 ;
48766 int res1 = 0 ;
48767 PyObject *swig_obj[1] ;
48768
48769 if (!args) SWIG_fail;
48770 swig_obj[0] = args;
48771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48772 if (!SWIG_IsOK(res1)) {
48773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48774 }
48775 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48776 {
48777 PyThreadState* __tstate = wxPyBeginAllowThreads();
48778 result = (int)((wxGBPosition const *)arg1)->GetCol();
48779 wxPyEndAllowThreads(__tstate);
48780 if (PyErr_Occurred()) SWIG_fail;
48781 }
48782 resultobj = SWIG_From_int(static_cast< int >(result));
48783 return resultobj;
48784 fail:
48785 return NULL;
48786 }
48787
48788
48789 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48790 PyObject *resultobj = 0;
48791 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48792 int arg2 ;
48793 void *argp1 = 0 ;
48794 int res1 = 0 ;
48795 int val2 ;
48796 int ecode2 = 0 ;
48797 PyObject * obj0 = 0 ;
48798 PyObject * obj1 = 0 ;
48799 char * kwnames[] = {
48800 (char *) "self",(char *) "row", NULL
48801 };
48802
48803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48805 if (!SWIG_IsOK(res1)) {
48806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48807 }
48808 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48809 ecode2 = SWIG_AsVal_int(obj1, &val2);
48810 if (!SWIG_IsOK(ecode2)) {
48811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48812 }
48813 arg2 = static_cast< int >(val2);
48814 {
48815 PyThreadState* __tstate = wxPyBeginAllowThreads();
48816 (arg1)->SetRow(arg2);
48817 wxPyEndAllowThreads(__tstate);
48818 if (PyErr_Occurred()) SWIG_fail;
48819 }
48820 resultobj = SWIG_Py_Void();
48821 return resultobj;
48822 fail:
48823 return NULL;
48824 }
48825
48826
48827 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48828 PyObject *resultobj = 0;
48829 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48830 int arg2 ;
48831 void *argp1 = 0 ;
48832 int res1 = 0 ;
48833 int val2 ;
48834 int ecode2 = 0 ;
48835 PyObject * obj0 = 0 ;
48836 PyObject * obj1 = 0 ;
48837 char * kwnames[] = {
48838 (char *) "self",(char *) "col", NULL
48839 };
48840
48841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48843 if (!SWIG_IsOK(res1)) {
48844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48845 }
48846 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48847 ecode2 = SWIG_AsVal_int(obj1, &val2);
48848 if (!SWIG_IsOK(ecode2)) {
48849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48850 }
48851 arg2 = static_cast< int >(val2);
48852 {
48853 PyThreadState* __tstate = wxPyBeginAllowThreads();
48854 (arg1)->SetCol(arg2);
48855 wxPyEndAllowThreads(__tstate);
48856 if (PyErr_Occurred()) SWIG_fail;
48857 }
48858 resultobj = SWIG_Py_Void();
48859 return resultobj;
48860 fail:
48861 return NULL;
48862 }
48863
48864
48865 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48866 PyObject *resultobj = 0;
48867 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48868 PyObject *arg2 = (PyObject *) 0 ;
48869 bool result;
48870 void *argp1 = 0 ;
48871 int res1 = 0 ;
48872 PyObject * obj0 = 0 ;
48873 PyObject * obj1 = 0 ;
48874 char * kwnames[] = {
48875 (char *) "self",(char *) "other", NULL
48876 };
48877
48878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48880 if (!SWIG_IsOK(res1)) {
48881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48882 }
48883 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48884 arg2 = obj1;
48885 {
48886 result = (bool)wxGBPosition___eq__(arg1,arg2);
48887 if (PyErr_Occurred()) SWIG_fail;
48888 }
48889 {
48890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48891 }
48892 return resultobj;
48893 fail:
48894 return NULL;
48895 }
48896
48897
48898 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48899 PyObject *resultobj = 0;
48900 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48901 PyObject *arg2 = (PyObject *) 0 ;
48902 bool result;
48903 void *argp1 = 0 ;
48904 int res1 = 0 ;
48905 PyObject * obj0 = 0 ;
48906 PyObject * obj1 = 0 ;
48907 char * kwnames[] = {
48908 (char *) "self",(char *) "other", NULL
48909 };
48910
48911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48913 if (!SWIG_IsOK(res1)) {
48914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48915 }
48916 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48917 arg2 = obj1;
48918 {
48919 result = (bool)wxGBPosition___ne__(arg1,arg2);
48920 if (PyErr_Occurred()) SWIG_fail;
48921 }
48922 {
48923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48924 }
48925 return resultobj;
48926 fail:
48927 return NULL;
48928 }
48929
48930
48931 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48932 PyObject *resultobj = 0;
48933 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48934 int arg2 = (int) 0 ;
48935 int arg3 = (int) 0 ;
48936 void *argp1 = 0 ;
48937 int res1 = 0 ;
48938 int val2 ;
48939 int ecode2 = 0 ;
48940 int val3 ;
48941 int ecode3 = 0 ;
48942 PyObject * obj0 = 0 ;
48943 PyObject * obj1 = 0 ;
48944 PyObject * obj2 = 0 ;
48945 char * kwnames[] = {
48946 (char *) "self",(char *) "row",(char *) "col", NULL
48947 };
48948
48949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48951 if (!SWIG_IsOK(res1)) {
48952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48953 }
48954 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48955 if (obj1) {
48956 ecode2 = SWIG_AsVal_int(obj1, &val2);
48957 if (!SWIG_IsOK(ecode2)) {
48958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48959 }
48960 arg2 = static_cast< int >(val2);
48961 }
48962 if (obj2) {
48963 ecode3 = SWIG_AsVal_int(obj2, &val3);
48964 if (!SWIG_IsOK(ecode3)) {
48965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48966 }
48967 arg3 = static_cast< int >(val3);
48968 }
48969 {
48970 PyThreadState* __tstate = wxPyBeginAllowThreads();
48971 wxGBPosition_Set(arg1,arg2,arg3);
48972 wxPyEndAllowThreads(__tstate);
48973 if (PyErr_Occurred()) SWIG_fail;
48974 }
48975 resultobj = SWIG_Py_Void();
48976 return resultobj;
48977 fail:
48978 return NULL;
48979 }
48980
48981
48982 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48983 PyObject *resultobj = 0;
48984 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48985 PyObject *result = 0 ;
48986 void *argp1 = 0 ;
48987 int res1 = 0 ;
48988 PyObject *swig_obj[1] ;
48989
48990 if (!args) SWIG_fail;
48991 swig_obj[0] = args;
48992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48993 if (!SWIG_IsOK(res1)) {
48994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48995 }
48996 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48997 {
48998 PyThreadState* __tstate = wxPyBeginAllowThreads();
48999 result = (PyObject *)wxGBPosition_Get(arg1);
49000 wxPyEndAllowThreads(__tstate);
49001 if (PyErr_Occurred()) SWIG_fail;
49002 }
49003 resultobj = result;
49004 return resultobj;
49005 fail:
49006 return NULL;
49007 }
49008
49009
49010 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49011 PyObject *obj;
49012 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49013 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49014 return SWIG_Py_Void();
49015 }
49016
49017 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49018 return SWIG_Python_InitShadowInstance(args);
49019 }
49020
49021 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49022 PyObject *resultobj = 0;
49023 int arg1 = (int) 1 ;
49024 int arg2 = (int) 1 ;
49025 wxGBSpan *result = 0 ;
49026 int val1 ;
49027 int ecode1 = 0 ;
49028 int val2 ;
49029 int ecode2 = 0 ;
49030 PyObject * obj0 = 0 ;
49031 PyObject * obj1 = 0 ;
49032 char * kwnames[] = {
49033 (char *) "rowspan",(char *) "colspan", NULL
49034 };
49035
49036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49037 if (obj0) {
49038 ecode1 = SWIG_AsVal_int(obj0, &val1);
49039 if (!SWIG_IsOK(ecode1)) {
49040 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49041 }
49042 arg1 = static_cast< int >(val1);
49043 }
49044 if (obj1) {
49045 ecode2 = SWIG_AsVal_int(obj1, &val2);
49046 if (!SWIG_IsOK(ecode2)) {
49047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49048 }
49049 arg2 = static_cast< int >(val2);
49050 }
49051 {
49052 PyThreadState* __tstate = wxPyBeginAllowThreads();
49053 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49054 wxPyEndAllowThreads(__tstate);
49055 if (PyErr_Occurred()) SWIG_fail;
49056 }
49057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49058 return resultobj;
49059 fail:
49060 return NULL;
49061 }
49062
49063
49064 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49065 PyObject *resultobj = 0;
49066 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49067 void *argp1 = 0 ;
49068 int res1 = 0 ;
49069 PyObject *swig_obj[1] ;
49070
49071 if (!args) SWIG_fail;
49072 swig_obj[0] = args;
49073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49074 if (!SWIG_IsOK(res1)) {
49075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49076 }
49077 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49078 {
49079 PyThreadState* __tstate = wxPyBeginAllowThreads();
49080 delete arg1;
49081
49082 wxPyEndAllowThreads(__tstate);
49083 if (PyErr_Occurred()) SWIG_fail;
49084 }
49085 resultobj = SWIG_Py_Void();
49086 return resultobj;
49087 fail:
49088 return NULL;
49089 }
49090
49091
49092 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49093 PyObject *resultobj = 0;
49094 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49095 int result;
49096 void *argp1 = 0 ;
49097 int res1 = 0 ;
49098 PyObject *swig_obj[1] ;
49099
49100 if (!args) SWIG_fail;
49101 swig_obj[0] = args;
49102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49103 if (!SWIG_IsOK(res1)) {
49104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49105 }
49106 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49107 {
49108 PyThreadState* __tstate = wxPyBeginAllowThreads();
49109 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49110 wxPyEndAllowThreads(__tstate);
49111 if (PyErr_Occurred()) SWIG_fail;
49112 }
49113 resultobj = SWIG_From_int(static_cast< int >(result));
49114 return resultobj;
49115 fail:
49116 return NULL;
49117 }
49118
49119
49120 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49121 PyObject *resultobj = 0;
49122 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49123 int result;
49124 void *argp1 = 0 ;
49125 int res1 = 0 ;
49126 PyObject *swig_obj[1] ;
49127
49128 if (!args) SWIG_fail;
49129 swig_obj[0] = args;
49130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49131 if (!SWIG_IsOK(res1)) {
49132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49133 }
49134 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49135 {
49136 PyThreadState* __tstate = wxPyBeginAllowThreads();
49137 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49138 wxPyEndAllowThreads(__tstate);
49139 if (PyErr_Occurred()) SWIG_fail;
49140 }
49141 resultobj = SWIG_From_int(static_cast< int >(result));
49142 return resultobj;
49143 fail:
49144 return NULL;
49145 }
49146
49147
49148 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49149 PyObject *resultobj = 0;
49150 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49151 int arg2 ;
49152 void *argp1 = 0 ;
49153 int res1 = 0 ;
49154 int val2 ;
49155 int ecode2 = 0 ;
49156 PyObject * obj0 = 0 ;
49157 PyObject * obj1 = 0 ;
49158 char * kwnames[] = {
49159 (char *) "self",(char *) "rowspan", NULL
49160 };
49161
49162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49164 if (!SWIG_IsOK(res1)) {
49165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49166 }
49167 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49168 ecode2 = SWIG_AsVal_int(obj1, &val2);
49169 if (!SWIG_IsOK(ecode2)) {
49170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49171 }
49172 arg2 = static_cast< int >(val2);
49173 {
49174 PyThreadState* __tstate = wxPyBeginAllowThreads();
49175 (arg1)->SetRowspan(arg2);
49176 wxPyEndAllowThreads(__tstate);
49177 if (PyErr_Occurred()) SWIG_fail;
49178 }
49179 resultobj = SWIG_Py_Void();
49180 return resultobj;
49181 fail:
49182 return NULL;
49183 }
49184
49185
49186 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49187 PyObject *resultobj = 0;
49188 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49189 int arg2 ;
49190 void *argp1 = 0 ;
49191 int res1 = 0 ;
49192 int val2 ;
49193 int ecode2 = 0 ;
49194 PyObject * obj0 = 0 ;
49195 PyObject * obj1 = 0 ;
49196 char * kwnames[] = {
49197 (char *) "self",(char *) "colspan", NULL
49198 };
49199
49200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49202 if (!SWIG_IsOK(res1)) {
49203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49204 }
49205 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49206 ecode2 = SWIG_AsVal_int(obj1, &val2);
49207 if (!SWIG_IsOK(ecode2)) {
49208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49209 }
49210 arg2 = static_cast< int >(val2);
49211 {
49212 PyThreadState* __tstate = wxPyBeginAllowThreads();
49213 (arg1)->SetColspan(arg2);
49214 wxPyEndAllowThreads(__tstate);
49215 if (PyErr_Occurred()) SWIG_fail;
49216 }
49217 resultobj = SWIG_Py_Void();
49218 return resultobj;
49219 fail:
49220 return NULL;
49221 }
49222
49223
49224 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49225 PyObject *resultobj = 0;
49226 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49227 PyObject *arg2 = (PyObject *) 0 ;
49228 bool result;
49229 void *argp1 = 0 ;
49230 int res1 = 0 ;
49231 PyObject * obj0 = 0 ;
49232 PyObject * obj1 = 0 ;
49233 char * kwnames[] = {
49234 (char *) "self",(char *) "other", NULL
49235 };
49236
49237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49239 if (!SWIG_IsOK(res1)) {
49240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49241 }
49242 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49243 arg2 = obj1;
49244 {
49245 result = (bool)wxGBSpan___eq__(arg1,arg2);
49246 if (PyErr_Occurred()) SWIG_fail;
49247 }
49248 {
49249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49250 }
49251 return resultobj;
49252 fail:
49253 return NULL;
49254 }
49255
49256
49257 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49258 PyObject *resultobj = 0;
49259 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49260 PyObject *arg2 = (PyObject *) 0 ;
49261 bool result;
49262 void *argp1 = 0 ;
49263 int res1 = 0 ;
49264 PyObject * obj0 = 0 ;
49265 PyObject * obj1 = 0 ;
49266 char * kwnames[] = {
49267 (char *) "self",(char *) "other", NULL
49268 };
49269
49270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49272 if (!SWIG_IsOK(res1)) {
49273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49274 }
49275 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49276 arg2 = obj1;
49277 {
49278 result = (bool)wxGBSpan___ne__(arg1,arg2);
49279 if (PyErr_Occurred()) SWIG_fail;
49280 }
49281 {
49282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49283 }
49284 return resultobj;
49285 fail:
49286 return NULL;
49287 }
49288
49289
49290 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49291 PyObject *resultobj = 0;
49292 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49293 int arg2 = (int) 1 ;
49294 int arg3 = (int) 1 ;
49295 void *argp1 = 0 ;
49296 int res1 = 0 ;
49297 int val2 ;
49298 int ecode2 = 0 ;
49299 int val3 ;
49300 int ecode3 = 0 ;
49301 PyObject * obj0 = 0 ;
49302 PyObject * obj1 = 0 ;
49303 PyObject * obj2 = 0 ;
49304 char * kwnames[] = {
49305 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49306 };
49307
49308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49310 if (!SWIG_IsOK(res1)) {
49311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49312 }
49313 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49314 if (obj1) {
49315 ecode2 = SWIG_AsVal_int(obj1, &val2);
49316 if (!SWIG_IsOK(ecode2)) {
49317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49318 }
49319 arg2 = static_cast< int >(val2);
49320 }
49321 if (obj2) {
49322 ecode3 = SWIG_AsVal_int(obj2, &val3);
49323 if (!SWIG_IsOK(ecode3)) {
49324 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49325 }
49326 arg3 = static_cast< int >(val3);
49327 }
49328 {
49329 PyThreadState* __tstate = wxPyBeginAllowThreads();
49330 wxGBSpan_Set(arg1,arg2,arg3);
49331 wxPyEndAllowThreads(__tstate);
49332 if (PyErr_Occurred()) SWIG_fail;
49333 }
49334 resultobj = SWIG_Py_Void();
49335 return resultobj;
49336 fail:
49337 return NULL;
49338 }
49339
49340
49341 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49342 PyObject *resultobj = 0;
49343 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49344 PyObject *result = 0 ;
49345 void *argp1 = 0 ;
49346 int res1 = 0 ;
49347 PyObject *swig_obj[1] ;
49348
49349 if (!args) SWIG_fail;
49350 swig_obj[0] = args;
49351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49352 if (!SWIG_IsOK(res1)) {
49353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49354 }
49355 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49356 {
49357 PyThreadState* __tstate = wxPyBeginAllowThreads();
49358 result = (PyObject *)wxGBSpan_Get(arg1);
49359 wxPyEndAllowThreads(__tstate);
49360 if (PyErr_Occurred()) SWIG_fail;
49361 }
49362 resultobj = result;
49363 return resultobj;
49364 fail:
49365 return NULL;
49366 }
49367
49368
49369 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49370 PyObject *obj;
49371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49372 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49373 return SWIG_Py_Void();
49374 }
49375
49376 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49377 return SWIG_Python_InitShadowInstance(args);
49378 }
49379
49380 SWIGINTERN int DefaultSpan_set(PyObject *) {
49381 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49382 return 1;
49383 }
49384
49385
49386 SWIGINTERN PyObject *DefaultSpan_get(void) {
49387 PyObject *pyobj = 0;
49388
49389 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49390 return pyobj;
49391 }
49392
49393
49394 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49395 PyObject *resultobj = 0;
49396 wxGBSizerItem *result = 0 ;
49397
49398 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49399 {
49400 PyThreadState* __tstate = wxPyBeginAllowThreads();
49401 result = (wxGBSizerItem *)new wxGBSizerItem();
49402 wxPyEndAllowThreads(__tstate);
49403 if (PyErr_Occurred()) SWIG_fail;
49404 }
49405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49406 return resultobj;
49407 fail:
49408 return NULL;
49409 }
49410
49411
49412 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49413 PyObject *resultobj = 0;
49414 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49415 void *argp1 = 0 ;
49416 int res1 = 0 ;
49417 PyObject *swig_obj[1] ;
49418
49419 if (!args) SWIG_fail;
49420 swig_obj[0] = args;
49421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49422 if (!SWIG_IsOK(res1)) {
49423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49424 }
49425 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49426 {
49427 PyThreadState* __tstate = wxPyBeginAllowThreads();
49428 delete arg1;
49429
49430 wxPyEndAllowThreads(__tstate);
49431 if (PyErr_Occurred()) SWIG_fail;
49432 }
49433 resultobj = SWIG_Py_Void();
49434 return resultobj;
49435 fail:
49436 return NULL;
49437 }
49438
49439
49440 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49441 PyObject *resultobj = 0;
49442 wxWindow *arg1 = (wxWindow *) 0 ;
49443 wxGBPosition *arg2 = 0 ;
49444 wxGBSpan *arg3 = 0 ;
49445 int arg4 ;
49446 int arg5 ;
49447 PyObject *arg6 = (PyObject *) NULL ;
49448 wxGBSizerItem *result = 0 ;
49449 void *argp1 = 0 ;
49450 int res1 = 0 ;
49451 wxGBPosition temp2 ;
49452 wxGBSpan temp3 ;
49453 int val4 ;
49454 int ecode4 = 0 ;
49455 int val5 ;
49456 int ecode5 = 0 ;
49457 PyObject * obj0 = 0 ;
49458 PyObject * obj1 = 0 ;
49459 PyObject * obj2 = 0 ;
49460 PyObject * obj3 = 0 ;
49461 PyObject * obj4 = 0 ;
49462 PyObject * obj5 = 0 ;
49463 char * kwnames[] = {
49464 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49465 };
49466
49467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49469 if (!SWIG_IsOK(res1)) {
49470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49471 }
49472 arg1 = reinterpret_cast< wxWindow * >(argp1);
49473 {
49474 arg2 = &temp2;
49475 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49476 }
49477 {
49478 arg3 = &temp3;
49479 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49480 }
49481 ecode4 = SWIG_AsVal_int(obj3, &val4);
49482 if (!SWIG_IsOK(ecode4)) {
49483 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49484 }
49485 arg4 = static_cast< int >(val4);
49486 ecode5 = SWIG_AsVal_int(obj4, &val5);
49487 if (!SWIG_IsOK(ecode5)) {
49488 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49489 }
49490 arg5 = static_cast< int >(val5);
49491 if (obj5) {
49492 arg6 = obj5;
49493 }
49494 {
49495 PyThreadState* __tstate = wxPyBeginAllowThreads();
49496 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49497 wxPyEndAllowThreads(__tstate);
49498 if (PyErr_Occurred()) SWIG_fail;
49499 }
49500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49501 return resultobj;
49502 fail:
49503 return NULL;
49504 }
49505
49506
49507 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49508 PyObject *resultobj = 0;
49509 wxSizer *arg1 = (wxSizer *) 0 ;
49510 wxGBPosition *arg2 = 0 ;
49511 wxGBSpan *arg3 = 0 ;
49512 int arg4 ;
49513 int arg5 ;
49514 PyObject *arg6 = (PyObject *) NULL ;
49515 wxGBSizerItem *result = 0 ;
49516 int res1 = 0 ;
49517 wxGBPosition temp2 ;
49518 wxGBSpan temp3 ;
49519 int val4 ;
49520 int ecode4 = 0 ;
49521 int val5 ;
49522 int ecode5 = 0 ;
49523 PyObject * obj0 = 0 ;
49524 PyObject * obj1 = 0 ;
49525 PyObject * obj2 = 0 ;
49526 PyObject * obj3 = 0 ;
49527 PyObject * obj4 = 0 ;
49528 PyObject * obj5 = 0 ;
49529 char * kwnames[] = {
49530 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49531 };
49532
49533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49534 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49535 if (!SWIG_IsOK(res1)) {
49536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49537 }
49538 {
49539 arg2 = &temp2;
49540 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49541 }
49542 {
49543 arg3 = &temp3;
49544 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49545 }
49546 ecode4 = SWIG_AsVal_int(obj3, &val4);
49547 if (!SWIG_IsOK(ecode4)) {
49548 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49549 }
49550 arg4 = static_cast< int >(val4);
49551 ecode5 = SWIG_AsVal_int(obj4, &val5);
49552 if (!SWIG_IsOK(ecode5)) {
49553 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49554 }
49555 arg5 = static_cast< int >(val5);
49556 if (obj5) {
49557 arg6 = obj5;
49558 }
49559 {
49560 PyThreadState* __tstate = wxPyBeginAllowThreads();
49561 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49562 wxPyEndAllowThreads(__tstate);
49563 if (PyErr_Occurred()) SWIG_fail;
49564 }
49565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49566 return resultobj;
49567 fail:
49568 return NULL;
49569 }
49570
49571
49572 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49573 PyObject *resultobj = 0;
49574 int arg1 ;
49575 int arg2 ;
49576 wxGBPosition *arg3 = 0 ;
49577 wxGBSpan *arg4 = 0 ;
49578 int arg5 ;
49579 int arg6 ;
49580 PyObject *arg7 = (PyObject *) NULL ;
49581 wxGBSizerItem *result = 0 ;
49582 int val1 ;
49583 int ecode1 = 0 ;
49584 int val2 ;
49585 int ecode2 = 0 ;
49586 wxGBPosition temp3 ;
49587 wxGBSpan temp4 ;
49588 int val5 ;
49589 int ecode5 = 0 ;
49590 int val6 ;
49591 int ecode6 = 0 ;
49592 PyObject * obj0 = 0 ;
49593 PyObject * obj1 = 0 ;
49594 PyObject * obj2 = 0 ;
49595 PyObject * obj3 = 0 ;
49596 PyObject * obj4 = 0 ;
49597 PyObject * obj5 = 0 ;
49598 PyObject * obj6 = 0 ;
49599 char * kwnames[] = {
49600 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49601 };
49602
49603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49604 ecode1 = SWIG_AsVal_int(obj0, &val1);
49605 if (!SWIG_IsOK(ecode1)) {
49606 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49607 }
49608 arg1 = static_cast< int >(val1);
49609 ecode2 = SWIG_AsVal_int(obj1, &val2);
49610 if (!SWIG_IsOK(ecode2)) {
49611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49612 }
49613 arg2 = static_cast< int >(val2);
49614 {
49615 arg3 = &temp3;
49616 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49617 }
49618 {
49619 arg4 = &temp4;
49620 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49621 }
49622 ecode5 = SWIG_AsVal_int(obj4, &val5);
49623 if (!SWIG_IsOK(ecode5)) {
49624 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49625 }
49626 arg5 = static_cast< int >(val5);
49627 ecode6 = SWIG_AsVal_int(obj5, &val6);
49628 if (!SWIG_IsOK(ecode6)) {
49629 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49630 }
49631 arg6 = static_cast< int >(val6);
49632 if (obj6) {
49633 arg7 = obj6;
49634 }
49635 {
49636 PyThreadState* __tstate = wxPyBeginAllowThreads();
49637 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49638 wxPyEndAllowThreads(__tstate);
49639 if (PyErr_Occurred()) SWIG_fail;
49640 }
49641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49642 return resultobj;
49643 fail:
49644 return NULL;
49645 }
49646
49647
49648 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49649 PyObject *resultobj = 0;
49650 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49651 wxGBPosition result;
49652 void *argp1 = 0 ;
49653 int res1 = 0 ;
49654 PyObject *swig_obj[1] ;
49655
49656 if (!args) SWIG_fail;
49657 swig_obj[0] = args;
49658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49659 if (!SWIG_IsOK(res1)) {
49660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49661 }
49662 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49663 {
49664 PyThreadState* __tstate = wxPyBeginAllowThreads();
49665 result = ((wxGBSizerItem const *)arg1)->GetPos();
49666 wxPyEndAllowThreads(__tstate);
49667 if (PyErr_Occurred()) SWIG_fail;
49668 }
49669 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49670 return resultobj;
49671 fail:
49672 return NULL;
49673 }
49674
49675
49676 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49677 PyObject *resultobj = 0;
49678 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49679 wxGBSpan result;
49680 void *argp1 = 0 ;
49681 int res1 = 0 ;
49682 PyObject *swig_obj[1] ;
49683
49684 if (!args) SWIG_fail;
49685 swig_obj[0] = args;
49686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49687 if (!SWIG_IsOK(res1)) {
49688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49689 }
49690 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49691 {
49692 PyThreadState* __tstate = wxPyBeginAllowThreads();
49693 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49694 wxPyEndAllowThreads(__tstate);
49695 if (PyErr_Occurred()) SWIG_fail;
49696 }
49697 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49698 return resultobj;
49699 fail:
49700 return NULL;
49701 }
49702
49703
49704 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49705 PyObject *resultobj = 0;
49706 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49707 wxGBPosition *arg2 = 0 ;
49708 bool result;
49709 void *argp1 = 0 ;
49710 int res1 = 0 ;
49711 wxGBPosition temp2 ;
49712 PyObject * obj0 = 0 ;
49713 PyObject * obj1 = 0 ;
49714 char * kwnames[] = {
49715 (char *) "self",(char *) "pos", NULL
49716 };
49717
49718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49720 if (!SWIG_IsOK(res1)) {
49721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49722 }
49723 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49724 {
49725 arg2 = &temp2;
49726 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49727 }
49728 {
49729 PyThreadState* __tstate = wxPyBeginAllowThreads();
49730 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49731 wxPyEndAllowThreads(__tstate);
49732 if (PyErr_Occurred()) SWIG_fail;
49733 }
49734 {
49735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49736 }
49737 return resultobj;
49738 fail:
49739 return NULL;
49740 }
49741
49742
49743 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49744 PyObject *resultobj = 0;
49745 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49746 wxGBSpan *arg2 = 0 ;
49747 bool result;
49748 void *argp1 = 0 ;
49749 int res1 = 0 ;
49750 wxGBSpan temp2 ;
49751 PyObject * obj0 = 0 ;
49752 PyObject * obj1 = 0 ;
49753 char * kwnames[] = {
49754 (char *) "self",(char *) "span", NULL
49755 };
49756
49757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49759 if (!SWIG_IsOK(res1)) {
49760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49761 }
49762 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49763 {
49764 arg2 = &temp2;
49765 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49766 }
49767 {
49768 PyThreadState* __tstate = wxPyBeginAllowThreads();
49769 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49770 wxPyEndAllowThreads(__tstate);
49771 if (PyErr_Occurred()) SWIG_fail;
49772 }
49773 {
49774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49775 }
49776 return resultobj;
49777 fail:
49778 return NULL;
49779 }
49780
49781
49782 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49783 PyObject *resultobj = 0;
49784 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49785 wxGBSizerItem *arg2 = 0 ;
49786 bool result;
49787 void *argp1 = 0 ;
49788 int res1 = 0 ;
49789 void *argp2 = 0 ;
49790 int res2 = 0 ;
49791 PyObject * obj0 = 0 ;
49792 PyObject * obj1 = 0 ;
49793 char * kwnames[] = {
49794 (char *) "self",(char *) "other", NULL
49795 };
49796
49797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49799 if (!SWIG_IsOK(res1)) {
49800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49801 }
49802 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49803 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49804 if (!SWIG_IsOK(res2)) {
49805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49806 }
49807 if (!argp2) {
49808 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49809 }
49810 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49811 {
49812 PyThreadState* __tstate = wxPyBeginAllowThreads();
49813 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49814 wxPyEndAllowThreads(__tstate);
49815 if (PyErr_Occurred()) SWIG_fail;
49816 }
49817 {
49818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49819 }
49820 return resultobj;
49821 fail:
49822 return NULL;
49823 }
49824
49825
49826 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49827 PyObject *resultobj = 0;
49828 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49829 wxGBPosition *arg2 = 0 ;
49830 wxGBSpan *arg3 = 0 ;
49831 bool result;
49832 void *argp1 = 0 ;
49833 int res1 = 0 ;
49834 wxGBPosition temp2 ;
49835 wxGBSpan temp3 ;
49836 PyObject * obj0 = 0 ;
49837 PyObject * obj1 = 0 ;
49838 PyObject * obj2 = 0 ;
49839 char * kwnames[] = {
49840 (char *) "self",(char *) "pos",(char *) "span", NULL
49841 };
49842
49843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49845 if (!SWIG_IsOK(res1)) {
49846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49847 }
49848 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49849 {
49850 arg2 = &temp2;
49851 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49852 }
49853 {
49854 arg3 = &temp3;
49855 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49856 }
49857 {
49858 PyThreadState* __tstate = wxPyBeginAllowThreads();
49859 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49860 wxPyEndAllowThreads(__tstate);
49861 if (PyErr_Occurred()) SWIG_fail;
49862 }
49863 {
49864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49865 }
49866 return resultobj;
49867 fail:
49868 return NULL;
49869 }
49870
49871
49872 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49873 PyObject *resultobj = 0;
49874 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49875 wxGBPosition result;
49876 void *argp1 = 0 ;
49877 int res1 = 0 ;
49878 PyObject *swig_obj[1] ;
49879
49880 if (!args) SWIG_fail;
49881 swig_obj[0] = args;
49882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49883 if (!SWIG_IsOK(res1)) {
49884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49885 }
49886 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49887 {
49888 PyThreadState* __tstate = wxPyBeginAllowThreads();
49889 result = wxGBSizerItem_GetEndPos(arg1);
49890 wxPyEndAllowThreads(__tstate);
49891 if (PyErr_Occurred()) SWIG_fail;
49892 }
49893 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49894 return resultobj;
49895 fail:
49896 return NULL;
49897 }
49898
49899
49900 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49901 PyObject *resultobj = 0;
49902 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49903 wxGridBagSizer *result = 0 ;
49904 void *argp1 = 0 ;
49905 int res1 = 0 ;
49906 PyObject *swig_obj[1] ;
49907
49908 if (!args) SWIG_fail;
49909 swig_obj[0] = args;
49910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49911 if (!SWIG_IsOK(res1)) {
49912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49913 }
49914 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49915 {
49916 PyThreadState* __tstate = wxPyBeginAllowThreads();
49917 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49918 wxPyEndAllowThreads(__tstate);
49919 if (PyErr_Occurred()) SWIG_fail;
49920 }
49921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49922 return resultobj;
49923 fail:
49924 return NULL;
49925 }
49926
49927
49928 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49929 PyObject *resultobj = 0;
49930 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49931 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49932 void *argp1 = 0 ;
49933 int res1 = 0 ;
49934 void *argp2 = 0 ;
49935 int res2 = 0 ;
49936 PyObject * obj0 = 0 ;
49937 PyObject * obj1 = 0 ;
49938 char * kwnames[] = {
49939 (char *) "self",(char *) "sizer", NULL
49940 };
49941
49942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49944 if (!SWIG_IsOK(res1)) {
49945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49946 }
49947 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49948 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49949 if (!SWIG_IsOK(res2)) {
49950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49951 }
49952 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49953 {
49954 PyThreadState* __tstate = wxPyBeginAllowThreads();
49955 (arg1)->SetGBSizer(arg2);
49956 wxPyEndAllowThreads(__tstate);
49957 if (PyErr_Occurred()) SWIG_fail;
49958 }
49959 resultobj = SWIG_Py_Void();
49960 return resultobj;
49961 fail:
49962 return NULL;
49963 }
49964
49965
49966 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49967 PyObject *obj;
49968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49969 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49970 return SWIG_Py_Void();
49971 }
49972
49973 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49974 return SWIG_Python_InitShadowInstance(args);
49975 }
49976
49977 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49978 PyObject *resultobj = 0;
49979 int arg1 = (int) 0 ;
49980 int arg2 = (int) 0 ;
49981 wxGridBagSizer *result = 0 ;
49982 int val1 ;
49983 int ecode1 = 0 ;
49984 int val2 ;
49985 int ecode2 = 0 ;
49986 PyObject * obj0 = 0 ;
49987 PyObject * obj1 = 0 ;
49988 char * kwnames[] = {
49989 (char *) "vgap",(char *) "hgap", NULL
49990 };
49991
49992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49993 if (obj0) {
49994 ecode1 = SWIG_AsVal_int(obj0, &val1);
49995 if (!SWIG_IsOK(ecode1)) {
49996 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49997 }
49998 arg1 = static_cast< int >(val1);
49999 }
50000 if (obj1) {
50001 ecode2 = SWIG_AsVal_int(obj1, &val2);
50002 if (!SWIG_IsOK(ecode2)) {
50003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50004 }
50005 arg2 = static_cast< int >(val2);
50006 }
50007 {
50008 PyThreadState* __tstate = wxPyBeginAllowThreads();
50009 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50010 wxPyEndAllowThreads(__tstate);
50011 if (PyErr_Occurred()) SWIG_fail;
50012 }
50013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50014 return resultobj;
50015 fail:
50016 return NULL;
50017 }
50018
50019
50020 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50021 PyObject *resultobj = 0;
50022 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50023 PyObject *arg2 = (PyObject *) 0 ;
50024 wxGBPosition *arg3 = 0 ;
50025 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50026 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50027 int arg5 = (int) 0 ;
50028 int arg6 = (int) 0 ;
50029 PyObject *arg7 = (PyObject *) NULL ;
50030 wxGBSizerItem *result = 0 ;
50031 void *argp1 = 0 ;
50032 int res1 = 0 ;
50033 wxGBPosition temp3 ;
50034 wxGBSpan temp4 ;
50035 int val5 ;
50036 int ecode5 = 0 ;
50037 int val6 ;
50038 int ecode6 = 0 ;
50039 PyObject * obj0 = 0 ;
50040 PyObject * obj1 = 0 ;
50041 PyObject * obj2 = 0 ;
50042 PyObject * obj3 = 0 ;
50043 PyObject * obj4 = 0 ;
50044 PyObject * obj5 = 0 ;
50045 PyObject * obj6 = 0 ;
50046 char * kwnames[] = {
50047 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50048 };
50049
50050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50052 if (!SWIG_IsOK(res1)) {
50053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50054 }
50055 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50056 arg2 = obj1;
50057 {
50058 arg3 = &temp3;
50059 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50060 }
50061 if (obj3) {
50062 {
50063 arg4 = &temp4;
50064 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50065 }
50066 }
50067 if (obj4) {
50068 ecode5 = SWIG_AsVal_int(obj4, &val5);
50069 if (!SWIG_IsOK(ecode5)) {
50070 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50071 }
50072 arg5 = static_cast< int >(val5);
50073 }
50074 if (obj5) {
50075 ecode6 = SWIG_AsVal_int(obj5, &val6);
50076 if (!SWIG_IsOK(ecode6)) {
50077 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50078 }
50079 arg6 = static_cast< int >(val6);
50080 }
50081 if (obj6) {
50082 arg7 = obj6;
50083 }
50084 {
50085 PyThreadState* __tstate = wxPyBeginAllowThreads();
50086 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50087 wxPyEndAllowThreads(__tstate);
50088 if (PyErr_Occurred()) SWIG_fail;
50089 }
50090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50091 return resultobj;
50092 fail:
50093 return NULL;
50094 }
50095
50096
50097 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50098 PyObject *resultobj = 0;
50099 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50100 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50101 wxGBSizerItem *result = 0 ;
50102 void *argp1 = 0 ;
50103 int res1 = 0 ;
50104 int res2 = 0 ;
50105 PyObject * obj0 = 0 ;
50106 PyObject * obj1 = 0 ;
50107 char * kwnames[] = {
50108 (char *) "self",(char *) "item", NULL
50109 };
50110
50111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50113 if (!SWIG_IsOK(res1)) {
50114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50115 }
50116 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50117 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50118 if (!SWIG_IsOK(res2)) {
50119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50120 }
50121 {
50122 PyThreadState* __tstate = wxPyBeginAllowThreads();
50123 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50124 wxPyEndAllowThreads(__tstate);
50125 if (PyErr_Occurred()) SWIG_fail;
50126 }
50127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50128 return resultobj;
50129 fail:
50130 return NULL;
50131 }
50132
50133
50134 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50135 PyObject *resultobj = 0;
50136 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50137 int arg2 ;
50138 int arg3 ;
50139 wxSize result;
50140 void *argp1 = 0 ;
50141 int res1 = 0 ;
50142 int val2 ;
50143 int ecode2 = 0 ;
50144 int val3 ;
50145 int ecode3 = 0 ;
50146 PyObject * obj0 = 0 ;
50147 PyObject * obj1 = 0 ;
50148 PyObject * obj2 = 0 ;
50149 char * kwnames[] = {
50150 (char *) "self",(char *) "row",(char *) "col", NULL
50151 };
50152
50153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50155 if (!SWIG_IsOK(res1)) {
50156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50157 }
50158 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50159 ecode2 = SWIG_AsVal_int(obj1, &val2);
50160 if (!SWIG_IsOK(ecode2)) {
50161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50162 }
50163 arg2 = static_cast< int >(val2);
50164 ecode3 = SWIG_AsVal_int(obj2, &val3);
50165 if (!SWIG_IsOK(ecode3)) {
50166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50167 }
50168 arg3 = static_cast< int >(val3);
50169 {
50170 PyThreadState* __tstate = wxPyBeginAllowThreads();
50171 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50172 wxPyEndAllowThreads(__tstate);
50173 if (PyErr_Occurred()) SWIG_fail;
50174 }
50175 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50176 return resultobj;
50177 fail:
50178 return NULL;
50179 }
50180
50181
50182 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50183 PyObject *resultobj = 0;
50184 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50185 wxSize result;
50186 void *argp1 = 0 ;
50187 int res1 = 0 ;
50188 PyObject *swig_obj[1] ;
50189
50190 if (!args) SWIG_fail;
50191 swig_obj[0] = args;
50192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50193 if (!SWIG_IsOK(res1)) {
50194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50195 }
50196 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50197 {
50198 PyThreadState* __tstate = wxPyBeginAllowThreads();
50199 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50200 wxPyEndAllowThreads(__tstate);
50201 if (PyErr_Occurred()) SWIG_fail;
50202 }
50203 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50204 return resultobj;
50205 fail:
50206 return NULL;
50207 }
50208
50209
50210 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50211 PyObject *resultobj = 0;
50212 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50213 wxSize *arg2 = 0 ;
50214 void *argp1 = 0 ;
50215 int res1 = 0 ;
50216 wxSize temp2 ;
50217 PyObject * obj0 = 0 ;
50218 PyObject * obj1 = 0 ;
50219 char * kwnames[] = {
50220 (char *) "self",(char *) "sz", NULL
50221 };
50222
50223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50225 if (!SWIG_IsOK(res1)) {
50226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50227 }
50228 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50229 {
50230 arg2 = &temp2;
50231 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50232 }
50233 {
50234 PyThreadState* __tstate = wxPyBeginAllowThreads();
50235 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50236 wxPyEndAllowThreads(__tstate);
50237 if (PyErr_Occurred()) SWIG_fail;
50238 }
50239 resultobj = SWIG_Py_Void();
50240 return resultobj;
50241 fail:
50242 return NULL;
50243 }
50244
50245
50246 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50247 PyObject *resultobj = 0;
50248 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50249 wxWindow *arg2 = (wxWindow *) 0 ;
50250 wxGBPosition result;
50251 void *argp1 = 0 ;
50252 int res1 = 0 ;
50253 void *argp2 = 0 ;
50254 int res2 = 0 ;
50255
50256 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50258 if (!SWIG_IsOK(res1)) {
50259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50260 }
50261 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50262 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50263 if (!SWIG_IsOK(res2)) {
50264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50265 }
50266 arg2 = reinterpret_cast< wxWindow * >(argp2);
50267 {
50268 PyThreadState* __tstate = wxPyBeginAllowThreads();
50269 result = (arg1)->GetItemPosition(arg2);
50270 wxPyEndAllowThreads(__tstate);
50271 if (PyErr_Occurred()) SWIG_fail;
50272 }
50273 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50274 return resultobj;
50275 fail:
50276 return NULL;
50277 }
50278
50279
50280 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50281 PyObject *resultobj = 0;
50282 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50283 wxSizer *arg2 = (wxSizer *) 0 ;
50284 wxGBPosition result;
50285 void *argp1 = 0 ;
50286 int res1 = 0 ;
50287 void *argp2 = 0 ;
50288 int res2 = 0 ;
50289
50290 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50292 if (!SWIG_IsOK(res1)) {
50293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50294 }
50295 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50296 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50297 if (!SWIG_IsOK(res2)) {
50298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50299 }
50300 arg2 = reinterpret_cast< wxSizer * >(argp2);
50301 {
50302 PyThreadState* __tstate = wxPyBeginAllowThreads();
50303 result = (arg1)->GetItemPosition(arg2);
50304 wxPyEndAllowThreads(__tstate);
50305 if (PyErr_Occurred()) SWIG_fail;
50306 }
50307 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50308 return resultobj;
50309 fail:
50310 return NULL;
50311 }
50312
50313
50314 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50315 PyObject *resultobj = 0;
50316 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50317 size_t arg2 ;
50318 wxGBPosition result;
50319 void *argp1 = 0 ;
50320 int res1 = 0 ;
50321 size_t val2 ;
50322 int ecode2 = 0 ;
50323
50324 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50326 if (!SWIG_IsOK(res1)) {
50327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50328 }
50329 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50330 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50331 if (!SWIG_IsOK(ecode2)) {
50332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50333 }
50334 arg2 = static_cast< size_t >(val2);
50335 {
50336 PyThreadState* __tstate = wxPyBeginAllowThreads();
50337 result = (arg1)->GetItemPosition(arg2);
50338 wxPyEndAllowThreads(__tstate);
50339 if (PyErr_Occurred()) SWIG_fail;
50340 }
50341 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50342 return resultobj;
50343 fail:
50344 return NULL;
50345 }
50346
50347
50348 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50349 int argc;
50350 PyObject *argv[3];
50351
50352 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50353 --argc;
50354 if (argc == 2) {
50355 int _v = 0;
50356 {
50357 void *vptr = 0;
50358 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50359 _v = SWIG_CheckState(res);
50360 }
50361 if (!_v) goto check_1;
50362 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50363 }
50364 check_1:
50365
50366 if (argc == 2) {
50367 int _v = 0;
50368 {
50369 void *vptr = 0;
50370 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50371 _v = SWIG_CheckState(res);
50372 }
50373 if (!_v) goto check_2;
50374 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50375 }
50376 check_2:
50377
50378 if (argc == 2) {
50379 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50380 }
50381
50382 fail:
50383 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50384 return NULL;
50385 }
50386
50387
50388 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50389 PyObject *resultobj = 0;
50390 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50391 wxWindow *arg2 = (wxWindow *) 0 ;
50392 wxGBPosition *arg3 = 0 ;
50393 bool result;
50394 void *argp1 = 0 ;
50395 int res1 = 0 ;
50396 void *argp2 = 0 ;
50397 int res2 = 0 ;
50398 wxGBPosition temp3 ;
50399
50400 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50402 if (!SWIG_IsOK(res1)) {
50403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50404 }
50405 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50406 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50407 if (!SWIG_IsOK(res2)) {
50408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50409 }
50410 arg2 = reinterpret_cast< wxWindow * >(argp2);
50411 {
50412 arg3 = &temp3;
50413 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50414 }
50415 {
50416 PyThreadState* __tstate = wxPyBeginAllowThreads();
50417 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50418 wxPyEndAllowThreads(__tstate);
50419 if (PyErr_Occurred()) SWIG_fail;
50420 }
50421 {
50422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50423 }
50424 return resultobj;
50425 fail:
50426 return NULL;
50427 }
50428
50429
50430 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50431 PyObject *resultobj = 0;
50432 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50433 wxSizer *arg2 = (wxSizer *) 0 ;
50434 wxGBPosition *arg3 = 0 ;
50435 bool result;
50436 void *argp1 = 0 ;
50437 int res1 = 0 ;
50438 void *argp2 = 0 ;
50439 int res2 = 0 ;
50440 wxGBPosition temp3 ;
50441
50442 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50444 if (!SWIG_IsOK(res1)) {
50445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50446 }
50447 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50448 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50449 if (!SWIG_IsOK(res2)) {
50450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50451 }
50452 arg2 = reinterpret_cast< wxSizer * >(argp2);
50453 {
50454 arg3 = &temp3;
50455 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50456 }
50457 {
50458 PyThreadState* __tstate = wxPyBeginAllowThreads();
50459 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50460 wxPyEndAllowThreads(__tstate);
50461 if (PyErr_Occurred()) SWIG_fail;
50462 }
50463 {
50464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50465 }
50466 return resultobj;
50467 fail:
50468 return NULL;
50469 }
50470
50471
50472 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50473 PyObject *resultobj = 0;
50474 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50475 size_t arg2 ;
50476 wxGBPosition *arg3 = 0 ;
50477 bool result;
50478 void *argp1 = 0 ;
50479 int res1 = 0 ;
50480 size_t val2 ;
50481 int ecode2 = 0 ;
50482 wxGBPosition temp3 ;
50483
50484 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50486 if (!SWIG_IsOK(res1)) {
50487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50488 }
50489 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50490 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50491 if (!SWIG_IsOK(ecode2)) {
50492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50493 }
50494 arg2 = static_cast< size_t >(val2);
50495 {
50496 arg3 = &temp3;
50497 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50498 }
50499 {
50500 PyThreadState* __tstate = wxPyBeginAllowThreads();
50501 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50502 wxPyEndAllowThreads(__tstate);
50503 if (PyErr_Occurred()) SWIG_fail;
50504 }
50505 {
50506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50507 }
50508 return resultobj;
50509 fail:
50510 return NULL;
50511 }
50512
50513
50514 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50515 int argc;
50516 PyObject *argv[4];
50517
50518 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50519 --argc;
50520 if (argc == 3) {
50521 int _v = 0;
50522 {
50523 void *vptr = 0;
50524 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50525 _v = SWIG_CheckState(res);
50526 }
50527 if (!_v) goto check_1;
50528 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50529 }
50530 check_1:
50531
50532 if (argc == 3) {
50533 int _v = 0;
50534 {
50535 void *vptr = 0;
50536 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50537 _v = SWIG_CheckState(res);
50538 }
50539 if (!_v) goto check_2;
50540 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50541 }
50542 check_2:
50543
50544 if (argc == 3) {
50545 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50546 }
50547
50548 fail:
50549 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50550 return NULL;
50551 }
50552
50553
50554 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50555 PyObject *resultobj = 0;
50556 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50557 wxWindow *arg2 = (wxWindow *) 0 ;
50558 wxGBSpan result;
50559 void *argp1 = 0 ;
50560 int res1 = 0 ;
50561 void *argp2 = 0 ;
50562 int res2 = 0 ;
50563
50564 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50566 if (!SWIG_IsOK(res1)) {
50567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50568 }
50569 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50570 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50571 if (!SWIG_IsOK(res2)) {
50572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50573 }
50574 arg2 = reinterpret_cast< wxWindow * >(argp2);
50575 {
50576 PyThreadState* __tstate = wxPyBeginAllowThreads();
50577 result = (arg1)->GetItemSpan(arg2);
50578 wxPyEndAllowThreads(__tstate);
50579 if (PyErr_Occurred()) SWIG_fail;
50580 }
50581 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50582 return resultobj;
50583 fail:
50584 return NULL;
50585 }
50586
50587
50588 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50589 PyObject *resultobj = 0;
50590 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50591 wxSizer *arg2 = (wxSizer *) 0 ;
50592 wxGBSpan result;
50593 void *argp1 = 0 ;
50594 int res1 = 0 ;
50595 void *argp2 = 0 ;
50596 int res2 = 0 ;
50597
50598 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50600 if (!SWIG_IsOK(res1)) {
50601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50602 }
50603 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50604 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50605 if (!SWIG_IsOK(res2)) {
50606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50607 }
50608 arg2 = reinterpret_cast< wxSizer * >(argp2);
50609 {
50610 PyThreadState* __tstate = wxPyBeginAllowThreads();
50611 result = (arg1)->GetItemSpan(arg2);
50612 wxPyEndAllowThreads(__tstate);
50613 if (PyErr_Occurred()) SWIG_fail;
50614 }
50615 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50616 return resultobj;
50617 fail:
50618 return NULL;
50619 }
50620
50621
50622 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50623 PyObject *resultobj = 0;
50624 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50625 size_t arg2 ;
50626 wxGBSpan result;
50627 void *argp1 = 0 ;
50628 int res1 = 0 ;
50629 size_t val2 ;
50630 int ecode2 = 0 ;
50631
50632 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50634 if (!SWIG_IsOK(res1)) {
50635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50636 }
50637 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50638 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50639 if (!SWIG_IsOK(ecode2)) {
50640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50641 }
50642 arg2 = static_cast< size_t >(val2);
50643 {
50644 PyThreadState* __tstate = wxPyBeginAllowThreads();
50645 result = (arg1)->GetItemSpan(arg2);
50646 wxPyEndAllowThreads(__tstate);
50647 if (PyErr_Occurred()) SWIG_fail;
50648 }
50649 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50650 return resultobj;
50651 fail:
50652 return NULL;
50653 }
50654
50655
50656 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50657 int argc;
50658 PyObject *argv[3];
50659
50660 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50661 --argc;
50662 if (argc == 2) {
50663 int _v = 0;
50664 {
50665 void *vptr = 0;
50666 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50667 _v = SWIG_CheckState(res);
50668 }
50669 if (!_v) goto check_1;
50670 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50671 }
50672 check_1:
50673
50674 if (argc == 2) {
50675 int _v = 0;
50676 {
50677 void *vptr = 0;
50678 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50679 _v = SWIG_CheckState(res);
50680 }
50681 if (!_v) goto check_2;
50682 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50683 }
50684 check_2:
50685
50686 if (argc == 2) {
50687 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50688 }
50689
50690 fail:
50691 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50692 return NULL;
50693 }
50694
50695
50696 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50697 PyObject *resultobj = 0;
50698 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50699 wxWindow *arg2 = (wxWindow *) 0 ;
50700 wxGBSpan *arg3 = 0 ;
50701 bool result;
50702 void *argp1 = 0 ;
50703 int res1 = 0 ;
50704 void *argp2 = 0 ;
50705 int res2 = 0 ;
50706 wxGBSpan temp3 ;
50707
50708 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50710 if (!SWIG_IsOK(res1)) {
50711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50712 }
50713 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50714 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50715 if (!SWIG_IsOK(res2)) {
50716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50717 }
50718 arg2 = reinterpret_cast< wxWindow * >(argp2);
50719 {
50720 arg3 = &temp3;
50721 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50722 }
50723 {
50724 PyThreadState* __tstate = wxPyBeginAllowThreads();
50725 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50726 wxPyEndAllowThreads(__tstate);
50727 if (PyErr_Occurred()) SWIG_fail;
50728 }
50729 {
50730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50731 }
50732 return resultobj;
50733 fail:
50734 return NULL;
50735 }
50736
50737
50738 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50739 PyObject *resultobj = 0;
50740 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50741 wxSizer *arg2 = (wxSizer *) 0 ;
50742 wxGBSpan *arg3 = 0 ;
50743 bool result;
50744 void *argp1 = 0 ;
50745 int res1 = 0 ;
50746 void *argp2 = 0 ;
50747 int res2 = 0 ;
50748 wxGBSpan temp3 ;
50749
50750 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50752 if (!SWIG_IsOK(res1)) {
50753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50754 }
50755 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50756 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50757 if (!SWIG_IsOK(res2)) {
50758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50759 }
50760 arg2 = reinterpret_cast< wxSizer * >(argp2);
50761 {
50762 arg3 = &temp3;
50763 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50764 }
50765 {
50766 PyThreadState* __tstate = wxPyBeginAllowThreads();
50767 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50768 wxPyEndAllowThreads(__tstate);
50769 if (PyErr_Occurred()) SWIG_fail;
50770 }
50771 {
50772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50773 }
50774 return resultobj;
50775 fail:
50776 return NULL;
50777 }
50778
50779
50780 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50781 PyObject *resultobj = 0;
50782 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50783 size_t arg2 ;
50784 wxGBSpan *arg3 = 0 ;
50785 bool result;
50786 void *argp1 = 0 ;
50787 int res1 = 0 ;
50788 size_t val2 ;
50789 int ecode2 = 0 ;
50790 wxGBSpan temp3 ;
50791
50792 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50794 if (!SWIG_IsOK(res1)) {
50795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50796 }
50797 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50798 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50799 if (!SWIG_IsOK(ecode2)) {
50800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50801 }
50802 arg2 = static_cast< size_t >(val2);
50803 {
50804 arg3 = &temp3;
50805 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50806 }
50807 {
50808 PyThreadState* __tstate = wxPyBeginAllowThreads();
50809 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50810 wxPyEndAllowThreads(__tstate);
50811 if (PyErr_Occurred()) SWIG_fail;
50812 }
50813 {
50814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50815 }
50816 return resultobj;
50817 fail:
50818 return NULL;
50819 }
50820
50821
50822 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50823 int argc;
50824 PyObject *argv[4];
50825
50826 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50827 --argc;
50828 if (argc == 3) {
50829 int _v = 0;
50830 {
50831 void *vptr = 0;
50832 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50833 _v = SWIG_CheckState(res);
50834 }
50835 if (!_v) goto check_1;
50836 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50837 }
50838 check_1:
50839
50840 if (argc == 3) {
50841 int _v = 0;
50842 {
50843 void *vptr = 0;
50844 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50845 _v = SWIG_CheckState(res);
50846 }
50847 if (!_v) goto check_2;
50848 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50849 }
50850 check_2:
50851
50852 if (argc == 3) {
50853 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50854 }
50855
50856 fail:
50857 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50858 return NULL;
50859 }
50860
50861
50862 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50863 PyObject *resultobj = 0;
50864 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50865 wxWindow *arg2 = (wxWindow *) 0 ;
50866 wxGBSizerItem *result = 0 ;
50867 void *argp1 = 0 ;
50868 int res1 = 0 ;
50869 void *argp2 = 0 ;
50870 int res2 = 0 ;
50871
50872 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50874 if (!SWIG_IsOK(res1)) {
50875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50876 }
50877 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50878 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50879 if (!SWIG_IsOK(res2)) {
50880 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50881 }
50882 arg2 = reinterpret_cast< wxWindow * >(argp2);
50883 {
50884 PyThreadState* __tstate = wxPyBeginAllowThreads();
50885 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50886 wxPyEndAllowThreads(__tstate);
50887 if (PyErr_Occurred()) SWIG_fail;
50888 }
50889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50890 return resultobj;
50891 fail:
50892 return NULL;
50893 }
50894
50895
50896 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50897 PyObject *resultobj = 0;
50898 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50899 wxSizer *arg2 = (wxSizer *) 0 ;
50900 wxGBSizerItem *result = 0 ;
50901 void *argp1 = 0 ;
50902 int res1 = 0 ;
50903 void *argp2 = 0 ;
50904 int res2 = 0 ;
50905
50906 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50908 if (!SWIG_IsOK(res1)) {
50909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50910 }
50911 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50912 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50913 if (!SWIG_IsOK(res2)) {
50914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50915 }
50916 arg2 = reinterpret_cast< wxSizer * >(argp2);
50917 {
50918 PyThreadState* __tstate = wxPyBeginAllowThreads();
50919 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50920 wxPyEndAllowThreads(__tstate);
50921 if (PyErr_Occurred()) SWIG_fail;
50922 }
50923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50924 return resultobj;
50925 fail:
50926 return NULL;
50927 }
50928
50929
50930 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50931 int argc;
50932 PyObject *argv[3];
50933
50934 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50935 --argc;
50936 if (argc == 2) {
50937 int _v = 0;
50938 {
50939 void *vptr = 0;
50940 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50941 _v = SWIG_CheckState(res);
50942 }
50943 if (!_v) goto check_1;
50944 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50945 }
50946 check_1:
50947
50948 if (argc == 2) {
50949 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50950 }
50951
50952 fail:
50953 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50954 return NULL;
50955 }
50956
50957
50958 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50959 PyObject *resultobj = 0;
50960 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50961 wxGBPosition *arg2 = 0 ;
50962 wxGBSizerItem *result = 0 ;
50963 void *argp1 = 0 ;
50964 int res1 = 0 ;
50965 wxGBPosition temp2 ;
50966 PyObject * obj0 = 0 ;
50967 PyObject * obj1 = 0 ;
50968 char * kwnames[] = {
50969 (char *) "self",(char *) "pos", NULL
50970 };
50971
50972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50974 if (!SWIG_IsOK(res1)) {
50975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50976 }
50977 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50978 {
50979 arg2 = &temp2;
50980 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50981 }
50982 {
50983 PyThreadState* __tstate = wxPyBeginAllowThreads();
50984 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50985 wxPyEndAllowThreads(__tstate);
50986 if (PyErr_Occurred()) SWIG_fail;
50987 }
50988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50989 return resultobj;
50990 fail:
50991 return NULL;
50992 }
50993
50994
50995 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50996 PyObject *resultobj = 0;
50997 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50998 wxPoint *arg2 = 0 ;
50999 wxGBSizerItem *result = 0 ;
51000 void *argp1 = 0 ;
51001 int res1 = 0 ;
51002 wxPoint temp2 ;
51003 PyObject * obj0 = 0 ;
51004 PyObject * obj1 = 0 ;
51005 char * kwnames[] = {
51006 (char *) "self",(char *) "pt", NULL
51007 };
51008
51009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51011 if (!SWIG_IsOK(res1)) {
51012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51013 }
51014 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51015 {
51016 arg2 = &temp2;
51017 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51018 }
51019 {
51020 PyThreadState* __tstate = wxPyBeginAllowThreads();
51021 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51022 wxPyEndAllowThreads(__tstate);
51023 if (PyErr_Occurred()) SWIG_fail;
51024 }
51025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51026 return resultobj;
51027 fail:
51028 return NULL;
51029 }
51030
51031
51032 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51033 PyObject *resultobj = 0;
51034 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51035 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51036 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51037 bool result;
51038 void *argp1 = 0 ;
51039 int res1 = 0 ;
51040 void *argp2 = 0 ;
51041 int res2 = 0 ;
51042 void *argp3 = 0 ;
51043 int res3 = 0 ;
51044 PyObject * obj0 = 0 ;
51045 PyObject * obj1 = 0 ;
51046 PyObject * obj2 = 0 ;
51047 char * kwnames[] = {
51048 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51049 };
51050
51051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51053 if (!SWIG_IsOK(res1)) {
51054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51055 }
51056 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51057 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51058 if (!SWIG_IsOK(res2)) {
51059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51060 }
51061 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51062 if (obj2) {
51063 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51064 if (!SWIG_IsOK(res3)) {
51065 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51066 }
51067 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51068 }
51069 {
51070 PyThreadState* __tstate = wxPyBeginAllowThreads();
51071 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51072 wxPyEndAllowThreads(__tstate);
51073 if (PyErr_Occurred()) SWIG_fail;
51074 }
51075 {
51076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51077 }
51078 return resultobj;
51079 fail:
51080 return NULL;
51081 }
51082
51083
51084 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51085 PyObject *resultobj = 0;
51086 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51087 wxGBPosition *arg2 = 0 ;
51088 wxGBSpan *arg3 = 0 ;
51089 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51090 bool result;
51091 void *argp1 = 0 ;
51092 int res1 = 0 ;
51093 wxGBPosition temp2 ;
51094 wxGBSpan temp3 ;
51095 void *argp4 = 0 ;
51096 int res4 = 0 ;
51097 PyObject * obj0 = 0 ;
51098 PyObject * obj1 = 0 ;
51099 PyObject * obj2 = 0 ;
51100 PyObject * obj3 = 0 ;
51101 char * kwnames[] = {
51102 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51103 };
51104
51105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51107 if (!SWIG_IsOK(res1)) {
51108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51109 }
51110 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51111 {
51112 arg2 = &temp2;
51113 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51114 }
51115 {
51116 arg3 = &temp3;
51117 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51118 }
51119 if (obj3) {
51120 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51121 if (!SWIG_IsOK(res4)) {
51122 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51123 }
51124 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51125 }
51126 {
51127 PyThreadState* __tstate = wxPyBeginAllowThreads();
51128 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51129 wxPyEndAllowThreads(__tstate);
51130 if (PyErr_Occurred()) SWIG_fail;
51131 }
51132 {
51133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51134 }
51135 return resultobj;
51136 fail:
51137 return NULL;
51138 }
51139
51140
51141 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51142 PyObject *obj;
51143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51144 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51145 return SWIG_Py_Void();
51146 }
51147
51148 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51149 return SWIG_Python_InitShadowInstance(args);
51150 }
51151
51152 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51153 PyObject *resultobj = 0;
51154 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51155 wxRelationship arg2 ;
51156 wxWindow *arg3 = (wxWindow *) 0 ;
51157 wxEdge arg4 ;
51158 int arg5 = (int) 0 ;
51159 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51160 void *argp1 = 0 ;
51161 int res1 = 0 ;
51162 int val2 ;
51163 int ecode2 = 0 ;
51164 void *argp3 = 0 ;
51165 int res3 = 0 ;
51166 int val4 ;
51167 int ecode4 = 0 ;
51168 int val5 ;
51169 int ecode5 = 0 ;
51170 int val6 ;
51171 int ecode6 = 0 ;
51172 PyObject * obj0 = 0 ;
51173 PyObject * obj1 = 0 ;
51174 PyObject * obj2 = 0 ;
51175 PyObject * obj3 = 0 ;
51176 PyObject * obj4 = 0 ;
51177 PyObject * obj5 = 0 ;
51178 char * kwnames[] = {
51179 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51180 };
51181
51182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51184 if (!SWIG_IsOK(res1)) {
51185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51186 }
51187 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51188 ecode2 = SWIG_AsVal_int(obj1, &val2);
51189 if (!SWIG_IsOK(ecode2)) {
51190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51191 }
51192 arg2 = static_cast< wxRelationship >(val2);
51193 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51194 if (!SWIG_IsOK(res3)) {
51195 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51196 }
51197 arg3 = reinterpret_cast< wxWindow * >(argp3);
51198 ecode4 = SWIG_AsVal_int(obj3, &val4);
51199 if (!SWIG_IsOK(ecode4)) {
51200 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51201 }
51202 arg4 = static_cast< wxEdge >(val4);
51203 if (obj4) {
51204 ecode5 = SWIG_AsVal_int(obj4, &val5);
51205 if (!SWIG_IsOK(ecode5)) {
51206 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51207 }
51208 arg5 = static_cast< int >(val5);
51209 }
51210 if (obj5) {
51211 ecode6 = SWIG_AsVal_int(obj5, &val6);
51212 if (!SWIG_IsOK(ecode6)) {
51213 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51214 }
51215 arg6 = static_cast< int >(val6);
51216 }
51217 {
51218 PyThreadState* __tstate = wxPyBeginAllowThreads();
51219 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51220 wxPyEndAllowThreads(__tstate);
51221 if (PyErr_Occurred()) SWIG_fail;
51222 }
51223 resultobj = SWIG_Py_Void();
51224 return resultobj;
51225 fail:
51226 return NULL;
51227 }
51228
51229
51230 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51231 PyObject *resultobj = 0;
51232 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51233 wxWindow *arg2 = (wxWindow *) 0 ;
51234 int arg3 = (int) 0 ;
51235 void *argp1 = 0 ;
51236 int res1 = 0 ;
51237 void *argp2 = 0 ;
51238 int res2 = 0 ;
51239 int val3 ;
51240 int ecode3 = 0 ;
51241 PyObject * obj0 = 0 ;
51242 PyObject * obj1 = 0 ;
51243 PyObject * obj2 = 0 ;
51244 char * kwnames[] = {
51245 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51246 };
51247
51248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51250 if (!SWIG_IsOK(res1)) {
51251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51252 }
51253 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51255 if (!SWIG_IsOK(res2)) {
51256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51257 }
51258 arg2 = reinterpret_cast< wxWindow * >(argp2);
51259 if (obj2) {
51260 ecode3 = SWIG_AsVal_int(obj2, &val3);
51261 if (!SWIG_IsOK(ecode3)) {
51262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51263 }
51264 arg3 = static_cast< int >(val3);
51265 }
51266 {
51267 PyThreadState* __tstate = wxPyBeginAllowThreads();
51268 (arg1)->LeftOf(arg2,arg3);
51269 wxPyEndAllowThreads(__tstate);
51270 if (PyErr_Occurred()) SWIG_fail;
51271 }
51272 resultobj = SWIG_Py_Void();
51273 return resultobj;
51274 fail:
51275 return NULL;
51276 }
51277
51278
51279 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51280 PyObject *resultobj = 0;
51281 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51282 wxWindow *arg2 = (wxWindow *) 0 ;
51283 int arg3 = (int) 0 ;
51284 void *argp1 = 0 ;
51285 int res1 = 0 ;
51286 void *argp2 = 0 ;
51287 int res2 = 0 ;
51288 int val3 ;
51289 int ecode3 = 0 ;
51290 PyObject * obj0 = 0 ;
51291 PyObject * obj1 = 0 ;
51292 PyObject * obj2 = 0 ;
51293 char * kwnames[] = {
51294 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51295 };
51296
51297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51299 if (!SWIG_IsOK(res1)) {
51300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51301 }
51302 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51303 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51304 if (!SWIG_IsOK(res2)) {
51305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51306 }
51307 arg2 = reinterpret_cast< wxWindow * >(argp2);
51308 if (obj2) {
51309 ecode3 = SWIG_AsVal_int(obj2, &val3);
51310 if (!SWIG_IsOK(ecode3)) {
51311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51312 }
51313 arg3 = static_cast< int >(val3);
51314 }
51315 {
51316 PyThreadState* __tstate = wxPyBeginAllowThreads();
51317 (arg1)->RightOf(arg2,arg3);
51318 wxPyEndAllowThreads(__tstate);
51319 if (PyErr_Occurred()) SWIG_fail;
51320 }
51321 resultobj = SWIG_Py_Void();
51322 return resultobj;
51323 fail:
51324 return NULL;
51325 }
51326
51327
51328 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51329 PyObject *resultobj = 0;
51330 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51331 wxWindow *arg2 = (wxWindow *) 0 ;
51332 int arg3 = (int) 0 ;
51333 void *argp1 = 0 ;
51334 int res1 = 0 ;
51335 void *argp2 = 0 ;
51336 int res2 = 0 ;
51337 int val3 ;
51338 int ecode3 = 0 ;
51339 PyObject * obj0 = 0 ;
51340 PyObject * obj1 = 0 ;
51341 PyObject * obj2 = 0 ;
51342 char * kwnames[] = {
51343 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51344 };
51345
51346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51348 if (!SWIG_IsOK(res1)) {
51349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51350 }
51351 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51352 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51353 if (!SWIG_IsOK(res2)) {
51354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51355 }
51356 arg2 = reinterpret_cast< wxWindow * >(argp2);
51357 if (obj2) {
51358 ecode3 = SWIG_AsVal_int(obj2, &val3);
51359 if (!SWIG_IsOK(ecode3)) {
51360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51361 }
51362 arg3 = static_cast< int >(val3);
51363 }
51364 {
51365 PyThreadState* __tstate = wxPyBeginAllowThreads();
51366 (arg1)->Above(arg2,arg3);
51367 wxPyEndAllowThreads(__tstate);
51368 if (PyErr_Occurred()) SWIG_fail;
51369 }
51370 resultobj = SWIG_Py_Void();
51371 return resultobj;
51372 fail:
51373 return NULL;
51374 }
51375
51376
51377 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51378 PyObject *resultobj = 0;
51379 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51380 wxWindow *arg2 = (wxWindow *) 0 ;
51381 int arg3 = (int) 0 ;
51382 void *argp1 = 0 ;
51383 int res1 = 0 ;
51384 void *argp2 = 0 ;
51385 int res2 = 0 ;
51386 int val3 ;
51387 int ecode3 = 0 ;
51388 PyObject * obj0 = 0 ;
51389 PyObject * obj1 = 0 ;
51390 PyObject * obj2 = 0 ;
51391 char * kwnames[] = {
51392 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51393 };
51394
51395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51397 if (!SWIG_IsOK(res1)) {
51398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51399 }
51400 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51401 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51402 if (!SWIG_IsOK(res2)) {
51403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51404 }
51405 arg2 = reinterpret_cast< wxWindow * >(argp2);
51406 if (obj2) {
51407 ecode3 = SWIG_AsVal_int(obj2, &val3);
51408 if (!SWIG_IsOK(ecode3)) {
51409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51410 }
51411 arg3 = static_cast< int >(val3);
51412 }
51413 {
51414 PyThreadState* __tstate = wxPyBeginAllowThreads();
51415 (arg1)->Below(arg2,arg3);
51416 wxPyEndAllowThreads(__tstate);
51417 if (PyErr_Occurred()) SWIG_fail;
51418 }
51419 resultobj = SWIG_Py_Void();
51420 return resultobj;
51421 fail:
51422 return NULL;
51423 }
51424
51425
51426 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51427 PyObject *resultobj = 0;
51428 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51429 wxWindow *arg2 = (wxWindow *) 0 ;
51430 wxEdge arg3 ;
51431 int arg4 = (int) 0 ;
51432 void *argp1 = 0 ;
51433 int res1 = 0 ;
51434 void *argp2 = 0 ;
51435 int res2 = 0 ;
51436 int val3 ;
51437 int ecode3 = 0 ;
51438 int val4 ;
51439 int ecode4 = 0 ;
51440 PyObject * obj0 = 0 ;
51441 PyObject * obj1 = 0 ;
51442 PyObject * obj2 = 0 ;
51443 PyObject * obj3 = 0 ;
51444 char * kwnames[] = {
51445 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51446 };
51447
51448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51450 if (!SWIG_IsOK(res1)) {
51451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51452 }
51453 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51454 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51455 if (!SWIG_IsOK(res2)) {
51456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51457 }
51458 arg2 = reinterpret_cast< wxWindow * >(argp2);
51459 ecode3 = SWIG_AsVal_int(obj2, &val3);
51460 if (!SWIG_IsOK(ecode3)) {
51461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51462 }
51463 arg3 = static_cast< wxEdge >(val3);
51464 if (obj3) {
51465 ecode4 = SWIG_AsVal_int(obj3, &val4);
51466 if (!SWIG_IsOK(ecode4)) {
51467 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51468 }
51469 arg4 = static_cast< int >(val4);
51470 }
51471 {
51472 PyThreadState* __tstate = wxPyBeginAllowThreads();
51473 (arg1)->SameAs(arg2,arg3,arg4);
51474 wxPyEndAllowThreads(__tstate);
51475 if (PyErr_Occurred()) SWIG_fail;
51476 }
51477 resultobj = SWIG_Py_Void();
51478 return resultobj;
51479 fail:
51480 return NULL;
51481 }
51482
51483
51484 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51485 PyObject *resultobj = 0;
51486 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51487 wxWindow *arg2 = (wxWindow *) 0 ;
51488 wxEdge arg3 ;
51489 int arg4 ;
51490 void *argp1 = 0 ;
51491 int res1 = 0 ;
51492 void *argp2 = 0 ;
51493 int res2 = 0 ;
51494 int val3 ;
51495 int ecode3 = 0 ;
51496 int val4 ;
51497 int ecode4 = 0 ;
51498 PyObject * obj0 = 0 ;
51499 PyObject * obj1 = 0 ;
51500 PyObject * obj2 = 0 ;
51501 PyObject * obj3 = 0 ;
51502 char * kwnames[] = {
51503 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51504 };
51505
51506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51508 if (!SWIG_IsOK(res1)) {
51509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51510 }
51511 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51512 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51513 if (!SWIG_IsOK(res2)) {
51514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51515 }
51516 arg2 = reinterpret_cast< wxWindow * >(argp2);
51517 ecode3 = SWIG_AsVal_int(obj2, &val3);
51518 if (!SWIG_IsOK(ecode3)) {
51519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51520 }
51521 arg3 = static_cast< wxEdge >(val3);
51522 ecode4 = SWIG_AsVal_int(obj3, &val4);
51523 if (!SWIG_IsOK(ecode4)) {
51524 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51525 }
51526 arg4 = static_cast< int >(val4);
51527 {
51528 PyThreadState* __tstate = wxPyBeginAllowThreads();
51529 (arg1)->PercentOf(arg2,arg3,arg4);
51530 wxPyEndAllowThreads(__tstate);
51531 if (PyErr_Occurred()) SWIG_fail;
51532 }
51533 resultobj = SWIG_Py_Void();
51534 return resultobj;
51535 fail:
51536 return NULL;
51537 }
51538
51539
51540 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51541 PyObject *resultobj = 0;
51542 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51543 int arg2 ;
51544 void *argp1 = 0 ;
51545 int res1 = 0 ;
51546 int val2 ;
51547 int ecode2 = 0 ;
51548 PyObject * obj0 = 0 ;
51549 PyObject * obj1 = 0 ;
51550 char * kwnames[] = {
51551 (char *) "self",(char *) "val", NULL
51552 };
51553
51554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51556 if (!SWIG_IsOK(res1)) {
51557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51558 }
51559 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51560 ecode2 = SWIG_AsVal_int(obj1, &val2);
51561 if (!SWIG_IsOK(ecode2)) {
51562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51563 }
51564 arg2 = static_cast< int >(val2);
51565 {
51566 PyThreadState* __tstate = wxPyBeginAllowThreads();
51567 (arg1)->Absolute(arg2);
51568 wxPyEndAllowThreads(__tstate);
51569 if (PyErr_Occurred()) SWIG_fail;
51570 }
51571 resultobj = SWIG_Py_Void();
51572 return resultobj;
51573 fail:
51574 return NULL;
51575 }
51576
51577
51578 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51579 PyObject *resultobj = 0;
51580 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51581 void *argp1 = 0 ;
51582 int res1 = 0 ;
51583 PyObject *swig_obj[1] ;
51584
51585 if (!args) SWIG_fail;
51586 swig_obj[0] = args;
51587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51588 if (!SWIG_IsOK(res1)) {
51589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51590 }
51591 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51592 {
51593 PyThreadState* __tstate = wxPyBeginAllowThreads();
51594 (arg1)->Unconstrained();
51595 wxPyEndAllowThreads(__tstate);
51596 if (PyErr_Occurred()) SWIG_fail;
51597 }
51598 resultobj = SWIG_Py_Void();
51599 return resultobj;
51600 fail:
51601 return NULL;
51602 }
51603
51604
51605 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51606 PyObject *resultobj = 0;
51607 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51608 void *argp1 = 0 ;
51609 int res1 = 0 ;
51610 PyObject *swig_obj[1] ;
51611
51612 if (!args) SWIG_fail;
51613 swig_obj[0] = args;
51614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51615 if (!SWIG_IsOK(res1)) {
51616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51617 }
51618 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51619 {
51620 PyThreadState* __tstate = wxPyBeginAllowThreads();
51621 (arg1)->AsIs();
51622 wxPyEndAllowThreads(__tstate);
51623 if (PyErr_Occurred()) SWIG_fail;
51624 }
51625 resultobj = SWIG_Py_Void();
51626 return resultobj;
51627 fail:
51628 return NULL;
51629 }
51630
51631
51632 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51633 PyObject *resultobj = 0;
51634 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51635 wxWindow *result = 0 ;
51636 void *argp1 = 0 ;
51637 int res1 = 0 ;
51638 PyObject *swig_obj[1] ;
51639
51640 if (!args) SWIG_fail;
51641 swig_obj[0] = args;
51642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51643 if (!SWIG_IsOK(res1)) {
51644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51645 }
51646 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51647 {
51648 PyThreadState* __tstate = wxPyBeginAllowThreads();
51649 result = (wxWindow *)(arg1)->GetOtherWindow();
51650 wxPyEndAllowThreads(__tstate);
51651 if (PyErr_Occurred()) SWIG_fail;
51652 }
51653 {
51654 resultobj = wxPyMake_wxObject(result, 0);
51655 }
51656 return resultobj;
51657 fail:
51658 return NULL;
51659 }
51660
51661
51662 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51663 PyObject *resultobj = 0;
51664 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51665 wxEdge result;
51666 void *argp1 = 0 ;
51667 int res1 = 0 ;
51668 PyObject *swig_obj[1] ;
51669
51670 if (!args) SWIG_fail;
51671 swig_obj[0] = args;
51672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51673 if (!SWIG_IsOK(res1)) {
51674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51675 }
51676 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51677 {
51678 PyThreadState* __tstate = wxPyBeginAllowThreads();
51679 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51680 wxPyEndAllowThreads(__tstate);
51681 if (PyErr_Occurred()) SWIG_fail;
51682 }
51683 resultobj = SWIG_From_int(static_cast< int >(result));
51684 return resultobj;
51685 fail:
51686 return NULL;
51687 }
51688
51689
51690 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51691 PyObject *resultobj = 0;
51692 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51693 wxEdge arg2 ;
51694 void *argp1 = 0 ;
51695 int res1 = 0 ;
51696 int val2 ;
51697 int ecode2 = 0 ;
51698 PyObject * obj0 = 0 ;
51699 PyObject * obj1 = 0 ;
51700 char * kwnames[] = {
51701 (char *) "self",(char *) "which", NULL
51702 };
51703
51704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51706 if (!SWIG_IsOK(res1)) {
51707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51708 }
51709 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51710 ecode2 = SWIG_AsVal_int(obj1, &val2);
51711 if (!SWIG_IsOK(ecode2)) {
51712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51713 }
51714 arg2 = static_cast< wxEdge >(val2);
51715 {
51716 PyThreadState* __tstate = wxPyBeginAllowThreads();
51717 (arg1)->SetEdge(arg2);
51718 wxPyEndAllowThreads(__tstate);
51719 if (PyErr_Occurred()) SWIG_fail;
51720 }
51721 resultobj = SWIG_Py_Void();
51722 return resultobj;
51723 fail:
51724 return NULL;
51725 }
51726
51727
51728 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51729 PyObject *resultobj = 0;
51730 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51731 int arg2 ;
51732 void *argp1 = 0 ;
51733 int res1 = 0 ;
51734 int val2 ;
51735 int ecode2 = 0 ;
51736 PyObject * obj0 = 0 ;
51737 PyObject * obj1 = 0 ;
51738 char * kwnames[] = {
51739 (char *) "self",(char *) "v", NULL
51740 };
51741
51742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51744 if (!SWIG_IsOK(res1)) {
51745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51746 }
51747 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51748 ecode2 = SWIG_AsVal_int(obj1, &val2);
51749 if (!SWIG_IsOK(ecode2)) {
51750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51751 }
51752 arg2 = static_cast< int >(val2);
51753 {
51754 PyThreadState* __tstate = wxPyBeginAllowThreads();
51755 (arg1)->SetValue(arg2);
51756 wxPyEndAllowThreads(__tstate);
51757 if (PyErr_Occurred()) SWIG_fail;
51758 }
51759 resultobj = SWIG_Py_Void();
51760 return resultobj;
51761 fail:
51762 return NULL;
51763 }
51764
51765
51766 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51767 PyObject *resultobj = 0;
51768 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51769 int result;
51770 void *argp1 = 0 ;
51771 int res1 = 0 ;
51772 PyObject *swig_obj[1] ;
51773
51774 if (!args) SWIG_fail;
51775 swig_obj[0] = args;
51776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51777 if (!SWIG_IsOK(res1)) {
51778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51779 }
51780 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51781 {
51782 PyThreadState* __tstate = wxPyBeginAllowThreads();
51783 result = (int)(arg1)->GetMargin();
51784 wxPyEndAllowThreads(__tstate);
51785 if (PyErr_Occurred()) SWIG_fail;
51786 }
51787 resultobj = SWIG_From_int(static_cast< int >(result));
51788 return resultobj;
51789 fail:
51790 return NULL;
51791 }
51792
51793
51794 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51795 PyObject *resultobj = 0;
51796 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51797 int arg2 ;
51798 void *argp1 = 0 ;
51799 int res1 = 0 ;
51800 int val2 ;
51801 int ecode2 = 0 ;
51802 PyObject * obj0 = 0 ;
51803 PyObject * obj1 = 0 ;
51804 char * kwnames[] = {
51805 (char *) "self",(char *) "m", NULL
51806 };
51807
51808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51810 if (!SWIG_IsOK(res1)) {
51811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51812 }
51813 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51814 ecode2 = SWIG_AsVal_int(obj1, &val2);
51815 if (!SWIG_IsOK(ecode2)) {
51816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51817 }
51818 arg2 = static_cast< int >(val2);
51819 {
51820 PyThreadState* __tstate = wxPyBeginAllowThreads();
51821 (arg1)->SetMargin(arg2);
51822 wxPyEndAllowThreads(__tstate);
51823 if (PyErr_Occurred()) SWIG_fail;
51824 }
51825 resultobj = SWIG_Py_Void();
51826 return resultobj;
51827 fail:
51828 return NULL;
51829 }
51830
51831
51832 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51833 PyObject *resultobj = 0;
51834 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51835 int result;
51836 void *argp1 = 0 ;
51837 int res1 = 0 ;
51838 PyObject *swig_obj[1] ;
51839
51840 if (!args) SWIG_fail;
51841 swig_obj[0] = args;
51842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51843 if (!SWIG_IsOK(res1)) {
51844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51845 }
51846 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51847 {
51848 PyThreadState* __tstate = wxPyBeginAllowThreads();
51849 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51850 wxPyEndAllowThreads(__tstate);
51851 if (PyErr_Occurred()) SWIG_fail;
51852 }
51853 resultobj = SWIG_From_int(static_cast< int >(result));
51854 return resultobj;
51855 fail:
51856 return NULL;
51857 }
51858
51859
51860 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51861 PyObject *resultobj = 0;
51862 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51863 int result;
51864 void *argp1 = 0 ;
51865 int res1 = 0 ;
51866 PyObject *swig_obj[1] ;
51867
51868 if (!args) SWIG_fail;
51869 swig_obj[0] = args;
51870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51871 if (!SWIG_IsOK(res1)) {
51872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51873 }
51874 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51875 {
51876 PyThreadState* __tstate = wxPyBeginAllowThreads();
51877 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51878 wxPyEndAllowThreads(__tstate);
51879 if (PyErr_Occurred()) SWIG_fail;
51880 }
51881 resultobj = SWIG_From_int(static_cast< int >(result));
51882 return resultobj;
51883 fail:
51884 return NULL;
51885 }
51886
51887
51888 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51889 PyObject *resultobj = 0;
51890 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51891 int result;
51892 void *argp1 = 0 ;
51893 int res1 = 0 ;
51894 PyObject *swig_obj[1] ;
51895
51896 if (!args) SWIG_fail;
51897 swig_obj[0] = args;
51898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51899 if (!SWIG_IsOK(res1)) {
51900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51901 }
51902 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51903 {
51904 PyThreadState* __tstate = wxPyBeginAllowThreads();
51905 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51906 wxPyEndAllowThreads(__tstate);
51907 if (PyErr_Occurred()) SWIG_fail;
51908 }
51909 resultobj = SWIG_From_int(static_cast< int >(result));
51910 return resultobj;
51911 fail:
51912 return NULL;
51913 }
51914
51915
51916 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51917 PyObject *resultobj = 0;
51918 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51919 bool result;
51920 void *argp1 = 0 ;
51921 int res1 = 0 ;
51922 PyObject *swig_obj[1] ;
51923
51924 if (!args) SWIG_fail;
51925 swig_obj[0] = args;
51926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51927 if (!SWIG_IsOK(res1)) {
51928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51929 }
51930 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51931 {
51932 PyThreadState* __tstate = wxPyBeginAllowThreads();
51933 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51934 wxPyEndAllowThreads(__tstate);
51935 if (PyErr_Occurred()) SWIG_fail;
51936 }
51937 {
51938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51939 }
51940 return resultobj;
51941 fail:
51942 return NULL;
51943 }
51944
51945
51946 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51947 PyObject *resultobj = 0;
51948 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51949 bool arg2 ;
51950 void *argp1 = 0 ;
51951 int res1 = 0 ;
51952 bool val2 ;
51953 int ecode2 = 0 ;
51954 PyObject * obj0 = 0 ;
51955 PyObject * obj1 = 0 ;
51956 char * kwnames[] = {
51957 (char *) "self",(char *) "d", NULL
51958 };
51959
51960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51962 if (!SWIG_IsOK(res1)) {
51963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51964 }
51965 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51966 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51967 if (!SWIG_IsOK(ecode2)) {
51968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51969 }
51970 arg2 = static_cast< bool >(val2);
51971 {
51972 PyThreadState* __tstate = wxPyBeginAllowThreads();
51973 (arg1)->SetDone(arg2);
51974 wxPyEndAllowThreads(__tstate);
51975 if (PyErr_Occurred()) SWIG_fail;
51976 }
51977 resultobj = SWIG_Py_Void();
51978 return resultobj;
51979 fail:
51980 return NULL;
51981 }
51982
51983
51984 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51985 PyObject *resultobj = 0;
51986 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51987 wxRelationship result;
51988 void *argp1 = 0 ;
51989 int res1 = 0 ;
51990 PyObject *swig_obj[1] ;
51991
51992 if (!args) SWIG_fail;
51993 swig_obj[0] = args;
51994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51995 if (!SWIG_IsOK(res1)) {
51996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51997 }
51998 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51999 {
52000 PyThreadState* __tstate = wxPyBeginAllowThreads();
52001 result = (wxRelationship)(arg1)->GetRelationship();
52002 wxPyEndAllowThreads(__tstate);
52003 if (PyErr_Occurred()) SWIG_fail;
52004 }
52005 resultobj = SWIG_From_int(static_cast< int >(result));
52006 return resultobj;
52007 fail:
52008 return NULL;
52009 }
52010
52011
52012 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52013 PyObject *resultobj = 0;
52014 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52015 wxRelationship arg2 ;
52016 void *argp1 = 0 ;
52017 int res1 = 0 ;
52018 int val2 ;
52019 int ecode2 = 0 ;
52020 PyObject * obj0 = 0 ;
52021 PyObject * obj1 = 0 ;
52022 char * kwnames[] = {
52023 (char *) "self",(char *) "r", NULL
52024 };
52025
52026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52028 if (!SWIG_IsOK(res1)) {
52029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52030 }
52031 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52032 ecode2 = SWIG_AsVal_int(obj1, &val2);
52033 if (!SWIG_IsOK(ecode2)) {
52034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52035 }
52036 arg2 = static_cast< wxRelationship >(val2);
52037 {
52038 PyThreadState* __tstate = wxPyBeginAllowThreads();
52039 (arg1)->SetRelationship(arg2);
52040 wxPyEndAllowThreads(__tstate);
52041 if (PyErr_Occurred()) SWIG_fail;
52042 }
52043 resultobj = SWIG_Py_Void();
52044 return resultobj;
52045 fail:
52046 return NULL;
52047 }
52048
52049
52050 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52051 PyObject *resultobj = 0;
52052 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52053 wxWindow *arg2 = (wxWindow *) 0 ;
52054 bool result;
52055 void *argp1 = 0 ;
52056 int res1 = 0 ;
52057 void *argp2 = 0 ;
52058 int res2 = 0 ;
52059 PyObject * obj0 = 0 ;
52060 PyObject * obj1 = 0 ;
52061 char * kwnames[] = {
52062 (char *) "self",(char *) "otherW", NULL
52063 };
52064
52065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52067 if (!SWIG_IsOK(res1)) {
52068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52069 }
52070 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52071 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52072 if (!SWIG_IsOK(res2)) {
52073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52074 }
52075 arg2 = reinterpret_cast< wxWindow * >(argp2);
52076 {
52077 PyThreadState* __tstate = wxPyBeginAllowThreads();
52078 result = (bool)(arg1)->ResetIfWin(arg2);
52079 wxPyEndAllowThreads(__tstate);
52080 if (PyErr_Occurred()) SWIG_fail;
52081 }
52082 {
52083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52084 }
52085 return resultobj;
52086 fail:
52087 return NULL;
52088 }
52089
52090
52091 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52092 PyObject *resultobj = 0;
52093 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52094 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52095 wxWindow *arg3 = (wxWindow *) 0 ;
52096 bool result;
52097 void *argp1 = 0 ;
52098 int res1 = 0 ;
52099 void *argp2 = 0 ;
52100 int res2 = 0 ;
52101 void *argp3 = 0 ;
52102 int res3 = 0 ;
52103 PyObject * obj0 = 0 ;
52104 PyObject * obj1 = 0 ;
52105 PyObject * obj2 = 0 ;
52106 char * kwnames[] = {
52107 (char *) "self",(char *) "constraints",(char *) "win", NULL
52108 };
52109
52110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52112 if (!SWIG_IsOK(res1)) {
52113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52114 }
52115 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52116 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52117 if (!SWIG_IsOK(res2)) {
52118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52119 }
52120 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52121 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52122 if (!SWIG_IsOK(res3)) {
52123 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52124 }
52125 arg3 = reinterpret_cast< wxWindow * >(argp3);
52126 {
52127 PyThreadState* __tstate = wxPyBeginAllowThreads();
52128 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52129 wxPyEndAllowThreads(__tstate);
52130 if (PyErr_Occurred()) SWIG_fail;
52131 }
52132 {
52133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52134 }
52135 return resultobj;
52136 fail:
52137 return NULL;
52138 }
52139
52140
52141 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52142 PyObject *resultobj = 0;
52143 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52144 wxEdge arg2 ;
52145 wxWindow *arg3 = (wxWindow *) 0 ;
52146 wxWindow *arg4 = (wxWindow *) 0 ;
52147 int result;
52148 void *argp1 = 0 ;
52149 int res1 = 0 ;
52150 int val2 ;
52151 int ecode2 = 0 ;
52152 void *argp3 = 0 ;
52153 int res3 = 0 ;
52154 void *argp4 = 0 ;
52155 int res4 = 0 ;
52156 PyObject * obj0 = 0 ;
52157 PyObject * obj1 = 0 ;
52158 PyObject * obj2 = 0 ;
52159 PyObject * obj3 = 0 ;
52160 char * kwnames[] = {
52161 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52162 };
52163
52164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52166 if (!SWIG_IsOK(res1)) {
52167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52168 }
52169 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52170 ecode2 = SWIG_AsVal_int(obj1, &val2);
52171 if (!SWIG_IsOK(ecode2)) {
52172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52173 }
52174 arg2 = static_cast< wxEdge >(val2);
52175 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52176 if (!SWIG_IsOK(res3)) {
52177 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52178 }
52179 arg3 = reinterpret_cast< wxWindow * >(argp3);
52180 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52181 if (!SWIG_IsOK(res4)) {
52182 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52183 }
52184 arg4 = reinterpret_cast< wxWindow * >(argp4);
52185 {
52186 PyThreadState* __tstate = wxPyBeginAllowThreads();
52187 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52188 wxPyEndAllowThreads(__tstate);
52189 if (PyErr_Occurred()) SWIG_fail;
52190 }
52191 resultobj = SWIG_From_int(static_cast< int >(result));
52192 return resultobj;
52193 fail:
52194 return NULL;
52195 }
52196
52197
52198 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52199 PyObject *obj;
52200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52201 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52202 return SWIG_Py_Void();
52203 }
52204
52205 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52206 PyObject *resultobj = 0;
52207 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52208 wxIndividualLayoutConstraint *result = 0 ;
52209 void *argp1 = 0 ;
52210 int res1 = 0 ;
52211 PyObject *swig_obj[1] ;
52212
52213 if (!args) SWIG_fail;
52214 swig_obj[0] = args;
52215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52216 if (!SWIG_IsOK(res1)) {
52217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52218 }
52219 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52220 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52222 return resultobj;
52223 fail:
52224 return NULL;
52225 }
52226
52227
52228 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52229 PyObject *resultobj = 0;
52230 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52231 wxIndividualLayoutConstraint *result = 0 ;
52232 void *argp1 = 0 ;
52233 int res1 = 0 ;
52234 PyObject *swig_obj[1] ;
52235
52236 if (!args) SWIG_fail;
52237 swig_obj[0] = args;
52238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52239 if (!SWIG_IsOK(res1)) {
52240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52241 }
52242 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52243 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52245 return resultobj;
52246 fail:
52247 return NULL;
52248 }
52249
52250
52251 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52252 PyObject *resultobj = 0;
52253 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52254 wxIndividualLayoutConstraint *result = 0 ;
52255 void *argp1 = 0 ;
52256 int res1 = 0 ;
52257 PyObject *swig_obj[1] ;
52258
52259 if (!args) SWIG_fail;
52260 swig_obj[0] = args;
52261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52262 if (!SWIG_IsOK(res1)) {
52263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52264 }
52265 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52266 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52268 return resultobj;
52269 fail:
52270 return NULL;
52271 }
52272
52273
52274 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52275 PyObject *resultobj = 0;
52276 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52277 wxIndividualLayoutConstraint *result = 0 ;
52278 void *argp1 = 0 ;
52279 int res1 = 0 ;
52280 PyObject *swig_obj[1] ;
52281
52282 if (!args) SWIG_fail;
52283 swig_obj[0] = args;
52284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52285 if (!SWIG_IsOK(res1)) {
52286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52287 }
52288 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52289 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52291 return resultobj;
52292 fail:
52293 return NULL;
52294 }
52295
52296
52297 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52298 PyObject *resultobj = 0;
52299 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52300 wxIndividualLayoutConstraint *result = 0 ;
52301 void *argp1 = 0 ;
52302 int res1 = 0 ;
52303 PyObject *swig_obj[1] ;
52304
52305 if (!args) SWIG_fail;
52306 swig_obj[0] = args;
52307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52308 if (!SWIG_IsOK(res1)) {
52309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52310 }
52311 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52312 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52314 return resultobj;
52315 fail:
52316 return NULL;
52317 }
52318
52319
52320 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52321 PyObject *resultobj = 0;
52322 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52323 wxIndividualLayoutConstraint *result = 0 ;
52324 void *argp1 = 0 ;
52325 int res1 = 0 ;
52326 PyObject *swig_obj[1] ;
52327
52328 if (!args) SWIG_fail;
52329 swig_obj[0] = args;
52330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52331 if (!SWIG_IsOK(res1)) {
52332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52333 }
52334 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52335 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52337 return resultobj;
52338 fail:
52339 return NULL;
52340 }
52341
52342
52343 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52344 PyObject *resultobj = 0;
52345 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52346 wxIndividualLayoutConstraint *result = 0 ;
52347 void *argp1 = 0 ;
52348 int res1 = 0 ;
52349 PyObject *swig_obj[1] ;
52350
52351 if (!args) SWIG_fail;
52352 swig_obj[0] = args;
52353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52354 if (!SWIG_IsOK(res1)) {
52355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52356 }
52357 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52358 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52360 return resultobj;
52361 fail:
52362 return NULL;
52363 }
52364
52365
52366 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52367 PyObject *resultobj = 0;
52368 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52369 wxIndividualLayoutConstraint *result = 0 ;
52370 void *argp1 = 0 ;
52371 int res1 = 0 ;
52372 PyObject *swig_obj[1] ;
52373
52374 if (!args) SWIG_fail;
52375 swig_obj[0] = args;
52376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52377 if (!SWIG_IsOK(res1)) {
52378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52379 }
52380 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52381 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52383 return resultobj;
52384 fail:
52385 return NULL;
52386 }
52387
52388
52389 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52390 PyObject *resultobj = 0;
52391 wxLayoutConstraints *result = 0 ;
52392
52393 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52394 {
52395 PyThreadState* __tstate = wxPyBeginAllowThreads();
52396 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52397 wxPyEndAllowThreads(__tstate);
52398 if (PyErr_Occurred()) SWIG_fail;
52399 }
52400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52401 return resultobj;
52402 fail:
52403 return NULL;
52404 }
52405
52406
52407 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52408 PyObject *resultobj = 0;
52409 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52410 void *argp1 = 0 ;
52411 int res1 = 0 ;
52412 PyObject *swig_obj[1] ;
52413
52414 if (!args) SWIG_fail;
52415 swig_obj[0] = args;
52416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52417 if (!SWIG_IsOK(res1)) {
52418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52419 }
52420 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52421 {
52422 PyThreadState* __tstate = wxPyBeginAllowThreads();
52423 delete arg1;
52424
52425 wxPyEndAllowThreads(__tstate);
52426 if (PyErr_Occurred()) SWIG_fail;
52427 }
52428 resultobj = SWIG_Py_Void();
52429 return resultobj;
52430 fail:
52431 return NULL;
52432 }
52433
52434
52435 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52436 PyObject *resultobj = 0;
52437 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52438 wxWindow *arg2 = (wxWindow *) 0 ;
52439 int *arg3 = (int *) 0 ;
52440 bool result;
52441 void *argp1 = 0 ;
52442 int res1 = 0 ;
52443 void *argp2 = 0 ;
52444 int res2 = 0 ;
52445 int temp3 ;
52446 int res3 = SWIG_TMPOBJ ;
52447 PyObject * obj0 = 0 ;
52448 PyObject * obj1 = 0 ;
52449 char * kwnames[] = {
52450 (char *) "self",(char *) "win", NULL
52451 };
52452
52453 arg3 = &temp3;
52454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52456 if (!SWIG_IsOK(res1)) {
52457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52458 }
52459 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52460 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52461 if (!SWIG_IsOK(res2)) {
52462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52463 }
52464 arg2 = reinterpret_cast< wxWindow * >(argp2);
52465 {
52466 PyThreadState* __tstate = wxPyBeginAllowThreads();
52467 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52468 wxPyEndAllowThreads(__tstate);
52469 if (PyErr_Occurred()) SWIG_fail;
52470 }
52471 {
52472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52473 }
52474 if (SWIG_IsTmpObj(res3)) {
52475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52476 } else {
52477 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52478 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52479 }
52480 return resultobj;
52481 fail:
52482 return NULL;
52483 }
52484
52485
52486 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52487 PyObject *resultobj = 0;
52488 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52489 bool result;
52490 void *argp1 = 0 ;
52491 int res1 = 0 ;
52492 PyObject *swig_obj[1] ;
52493
52494 if (!args) SWIG_fail;
52495 swig_obj[0] = args;
52496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52497 if (!SWIG_IsOK(res1)) {
52498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52499 }
52500 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52501 {
52502 PyThreadState* __tstate = wxPyBeginAllowThreads();
52503 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52504 wxPyEndAllowThreads(__tstate);
52505 if (PyErr_Occurred()) SWIG_fail;
52506 }
52507 {
52508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52509 }
52510 return resultobj;
52511 fail:
52512 return NULL;
52513 }
52514
52515
52516 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52517 PyObject *obj;
52518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52519 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52520 return SWIG_Py_Void();
52521 }
52522
52523 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52524 return SWIG_Python_InitShadowInstance(args);
52525 }
52526
52527 static PyMethodDef SwigMethods[] = {
52528 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52529 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52530 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52531 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52532 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52533 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52534 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52535 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52536 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52537 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52538 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52539 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52540 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52541 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52542 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52543 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52544 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52545 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52546 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52547 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52548 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52549 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52550 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52551 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52552 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52553 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52554 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52555 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52556 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52557 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52558 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52560 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52561 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52562 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52563 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52564 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52565 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52566 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52567 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52568 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52569 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52570 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52571 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52572 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52573 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52574 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52575 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52576 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52577 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52578 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52579 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52580 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52581 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52582 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52583 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52584 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52585 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52586 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52587 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52588 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52589 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52590 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52591 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52592 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52593 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52594 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52596 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52597 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52598 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52599 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52600 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52601 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52602 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52603 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52604 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52605 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52606 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52607 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52608 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52609 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52610 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52611 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52612 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52613 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52614 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52615 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52616 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52617 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52618 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52621 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52623 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52624 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52627 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52628 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52629 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52630 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52631 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52632 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52633 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52634 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52635 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52636 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52637 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52638 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52639 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52640 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52641 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52642 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52643 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52644 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52645 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52646 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52647 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52648 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52649 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52651 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52653 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52655 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52656 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52657 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52658 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52659 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52660 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52661 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52662 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52663 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52664 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52665 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52666 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52667 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52668 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52669 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52670 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52671 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52672 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52673 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52674 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52675 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52677 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52678 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52679 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52680 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52681 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52682 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52683 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52684 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52685 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52686 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52687 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52688 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52689 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52691 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52692 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52693 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52694 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52695 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52696 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52697 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52698 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52699 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52700 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52701 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52702 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52703 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52704 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52705 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52706 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52707 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52708 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52709 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52710 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52711 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52712 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52715 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52716 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52717 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52718 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52719 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52720 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52721 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52722 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52723 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52724 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52725 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52726 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52727 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52728 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52729 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52730 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52731 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52732 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52733 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52734 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52735 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52736 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52737 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52738 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52739 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52740 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52741 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52745 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52746 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52747 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52748 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52749 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52750 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52751 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52752 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52753 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52754 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52755 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52756 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52757 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52760 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52762 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52763 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52765 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52766 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52767 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52770 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52772 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52773 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52774 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52776 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52777 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52778 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52779 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52780 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52781 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52782 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52783 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52785 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52786 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52787 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52788 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52789 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52790 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52791 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52792 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52794 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52802 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52803 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52804 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52815 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52816 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52823 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52826 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52827 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52828 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52829 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52830 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52831 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52832 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52833 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52834 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52837 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52839 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52841 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52843 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52845 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52848 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52849 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52850 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52851 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52853 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52855 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52858 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52867 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52868 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52869 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52870 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52871 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52877 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52878 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52879 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52880 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52881 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52882 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52883 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52884 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52885 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52886 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52887 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52888 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52889 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52890 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52891 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52892 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52893 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52894 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52895 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52896 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52897 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52898 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52899 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52900 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52901 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52902 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52903 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52904 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52905 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52906 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52907 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52908 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52909 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52910 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52911 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52913 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52914 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52915 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52916 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52917 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52919 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52923 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52927 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52928 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52929 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52930 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52932 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52933 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52934 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52935 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52937 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52939 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52940 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52941 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52942 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52943 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52945 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52946 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52947 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52948 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52949 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52950 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52952 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52953 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52954 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52956 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52958 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52959 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52960 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52962 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52964 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52965 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52966 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52967 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52968 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52969 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52970 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52971 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52972 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52973 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52974 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52975 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52976 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52977 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52978 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52979 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52981 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52982 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52983 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52984 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52985 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52988 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52989 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52990 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52991 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52992 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52996 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52997 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52998 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52999 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53000 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53001 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53002 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53003 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53004 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53005 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53006 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53007 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53008 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53009 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53010 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53011 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53012 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53013 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53014 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53015 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53016 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53017 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53018 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53019 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53020 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53022 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53023 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53024 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53025 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53026 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53027 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53028 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53029 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53030 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53031 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53032 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53033 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53034 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53035 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53036 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53037 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53038 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53039 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53040 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53041 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53042 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53043 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53044 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53045 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53046 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53047 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53048 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53049 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53050 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53051 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53052 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53053 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53055 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53056 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53058 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53059 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53060 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53061 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53063 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53064 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53065 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53066 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53067 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53068 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53069 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53070 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53071 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53072 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53073 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53074 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53075 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53076 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53077 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53078 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53079 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53080 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53081 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53082 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53083 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53084 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53085 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53086 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53087 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53088 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53089 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53090 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53091 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53092 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53093 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53094 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53095 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53096 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53097 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53098 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53099 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53101 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53102 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53105 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53106 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53107 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53108 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53109 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53110 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53112 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53113 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53116 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53117 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53119 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53120 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53122 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53123 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53125 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53126 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53127 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53129 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53131 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53132 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53134 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53135 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53136 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53138 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53139 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53140 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53142 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53143 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53145 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53146 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53147 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53148 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53149 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53152 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53154 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53156 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53157 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53158 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53161 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53162 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53163 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53165 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53166 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53167 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53169 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53170 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53171 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53172 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53173 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53174 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53176 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53177 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53178 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53179 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53180 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53181 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53182 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53183 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53189 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53191 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53193 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53194 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53195 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53196 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53197 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53198 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53200 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53201 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53202 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53203 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53204 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53205 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53208 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53209 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53210 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53211 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53213 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53214 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53215 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53216 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53217 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53219 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53221 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53224 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53226 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53227 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53229 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53230 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53231 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53233 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53234 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53235 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53237 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53239 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53240 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53241 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53242 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53243 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53245 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53247 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53248 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53250 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53251 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53253 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53255 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53256 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53257 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53259 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53261 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53262 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53263 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53265 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53267 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53268 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53269 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53270 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53272 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53274 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53276 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53278 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53279 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53281 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53282 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53283 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53284 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53285 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53286 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53287 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53288 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53290 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53292 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53294 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53296 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53298 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53299 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53300 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53301 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53302 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53303 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53304 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53305 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53310 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53311 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53312 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53313 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53314 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53315 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53316 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53317 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53319 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53321 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53322 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53324 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53325 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53326 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53327 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53329 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53330 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53331 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53332 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53334 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53335 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53337 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53338 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53339 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53341 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53343 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53344 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53345 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53346 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53347 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53349 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53350 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53351 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53352 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53354 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53355 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53356 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53357 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53358 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53359 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53360 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53361 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53362 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53363 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53365 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53366 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53368 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53369 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53370 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53372 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53374 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53376 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53378 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53379 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53389 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53390 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53394 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53395 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53396 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53397 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53398 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53399 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53400 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53401 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53402 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53403 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53404 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53405 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53406 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53407 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53408 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53410 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53411 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53414 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53415 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53420 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53421 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53424 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53425 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53426 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53427 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53430 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53431 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53432 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53434 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53436 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53437 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53438 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53440 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53442 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53444 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53447 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53448 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53449 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53450 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53451 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53452 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53453 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53459 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53460 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53461 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53462 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53468 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53474 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53475 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53476 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53477 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53478 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53480 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53490 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53491 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53492 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53493 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53496 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53497 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53498 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53499 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53501 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53502 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53506 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53512 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53513 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53514 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53515 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53517 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53518 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53520 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53523 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53525 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53526 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53527 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53536 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53540 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53542 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53552 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53553 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53554 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53555 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53558 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53561 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53563 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53566 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53568 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53569 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53572 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53574 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53575 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53576 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53577 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53578 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53583 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53584 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53585 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53587 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53588 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53589 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53591 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53592 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53593 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53594 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53595 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53597 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53598 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53601 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53609 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53616 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53619 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53624 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53627 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53628 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53641 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53643 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53645 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53646 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53648 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53650 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53651 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53653 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53654 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53655 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53659 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53678 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53679 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53681 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53683 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53684 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53685 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53687 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53688 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53691 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53692 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53694 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53695 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53697 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53700 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53701 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53703 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53705 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53707 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53708 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53710 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53711 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53714 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53716 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53718 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53720 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53723 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53725 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53726 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53727 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53729 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53730 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53731 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53733 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53736 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53738 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53739 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53743 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53747 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53748 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53750 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53754 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53756 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53758 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53759 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53760 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53761 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53765 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53766 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53767 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53768 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53770 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53771 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53776 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53777 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53778 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53779 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53780 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53782 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53784 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53786 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53787 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53789 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53791 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53794 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53795 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53796 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53798 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53799 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53800 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53814 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53815 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53816 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53817 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53818 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53819 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53825 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53826 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53830 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53831 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53833 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53834 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53836 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53838 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53839 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53841 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53842 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53843 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53849 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53850 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53851 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53852 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53853 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53854 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53861 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53863 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53864 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53865 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53866 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53867 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53868 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53870 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53874 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53875 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53876 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53877 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53878 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53879 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53880 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53882 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53883 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53884 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53890 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53891 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53892 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53894 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53895 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53896 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53902 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53903 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53904 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53905 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53906 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53910 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53911 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53916 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53917 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53919 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53920 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53925 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53927 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53928 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53929 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53930 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53931 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53936 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53937 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53946 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53947 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53948 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53949 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53952 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53954 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53955 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53956 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53957 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53959 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53964 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53965 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53966 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53967 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53968 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53969 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53970 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53971 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53972 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53973 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53974 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53976 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53977 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53978 { NULL, NULL, 0, NULL }
53979 };
53980
53981
53982 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53983
53984 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53985 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53986 }
53987 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53988 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53989 }
53990 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53991 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53992 }
53993 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53994 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53995 }
53996 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53997 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53998 }
53999 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54000 return (void *)((wxSizer *) ((wxGridSizer *) x));
54001 }
54002 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54003 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54004 }
54005 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54006 return (void *)((wxSizer *) ((wxPySizer *) x));
54007 }
54008 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54009 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54010 }
54011 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54012 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54013 }
54014 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54015 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54016 }
54017 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54018 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54019 }
54020 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54021 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54022 }
54023 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54024 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54025 }
54026 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54027 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54028 }
54029 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54030 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54031 }
54032 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54033 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54034 }
54035 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54036 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54037 }
54038 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54039 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54040 }
54041 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54042 return (void *)((wxEvent *) ((wxPyEvent *) x));
54043 }
54044 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54045 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54046 }
54047 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54048 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54049 }
54050 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54051 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54052 }
54053 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54054 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54055 }
54056 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54057 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54058 }
54059 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54060 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54061 }
54062 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54063 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54064 }
54065 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54066 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54067 }
54068 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54069 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54070 }
54071 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54072 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54073 }
54074 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54075 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54076 }
54077 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54078 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54079 }
54080 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54081 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54082 }
54083 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54084 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54085 }
54086 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54087 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54088 }
54089 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54090 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54091 }
54092 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54093 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54094 }
54095 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54096 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54097 }
54098 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54099 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54100 }
54101 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54102 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54103 }
54104 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54105 return (void *)((wxEvent *) ((wxShowEvent *) x));
54106 }
54107 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54108 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54109 }
54110 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54111 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54112 }
54113 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54114 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54115 }
54116 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54117 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54118 }
54119 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54120 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54121 }
54122 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54123 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54124 }
54125 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54126 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54127 }
54128 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54129 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54130 }
54131 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54132 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54133 }
54134 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54135 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54136 }
54137 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54138 return (void *)((wxControl *) ((wxControlWithItems *) x));
54139 }
54140 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54141 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54142 }
54143 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54144 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54145 }
54146 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54147 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54148 }
54149 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54150 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54151 }
54152 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54153 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54154 }
54155 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54156 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54157 }
54158 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54159 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54160 }
54161 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54162 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54163 }
54164 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54165 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54166 }
54167 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54168 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54169 }
54170 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54171 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54172 }
54173 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54174 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54175 }
54176 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54177 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54178 }
54179 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54180 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54181 }
54182 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54183 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54184 }
54185 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54186 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54187 }
54188 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54189 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54190 }
54191 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54192 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54193 }
54194 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54195 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54196 }
54197 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54198 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54199 }
54200 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54201 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54202 }
54203 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54204 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54205 }
54206 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54207 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54208 }
54209 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54210 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54211 }
54212 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54213 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54214 }
54215 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54216 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54217 }
54218 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54219 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54220 }
54221 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54222 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54223 }
54224 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54225 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54226 }
54227 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54228 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54229 }
54230 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54231 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54232 }
54233 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54234 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54235 }
54236 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54237 return (void *)((wxObject *) ((wxSizerItem *) x));
54238 }
54239 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54240 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54241 }
54242 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54243 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54244 }
54245 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54246 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54247 }
54248 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54249 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54250 }
54251 static void *_p_wxSizerTo_p_wxObject(void *x) {
54252 return (void *)((wxObject *) ((wxSizer *) x));
54253 }
54254 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54255 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54256 }
54257 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54258 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54259 }
54260 static void *_p_wxEventTo_p_wxObject(void *x) {
54261 return (void *)((wxObject *) ((wxEvent *) x));
54262 }
54263 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54264 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54265 }
54266 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54267 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54268 }
54269 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54270 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54271 }
54272 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54273 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54274 }
54275 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54276 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54277 }
54278 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54279 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54280 }
54281 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54282 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54283 }
54284 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54285 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54286 }
54287 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54288 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54289 }
54290 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54291 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54292 }
54293 static void *_p_wxControlTo_p_wxObject(void *x) {
54294 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54295 }
54296 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54297 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54298 }
54299 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54300 return (void *)((wxObject *) ((wxFSFile *) x));
54301 }
54302 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54303 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54304 }
54305 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54306 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54307 }
54308 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54309 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54310 }
54311 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54312 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54313 }
54314 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54315 return (void *)((wxObject *) ((wxMenuItem *) x));
54316 }
54317 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54318 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54319 }
54320 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54321 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54322 }
54323 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54324 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54325 }
54326 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54327 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54328 }
54329 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54330 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54331 }
54332 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54333 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54334 }
54335 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54336 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54337 }
54338 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54339 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54340 }
54341 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54342 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54343 }
54344 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54345 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54346 }
54347 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54348 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54349 }
54350 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54351 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54352 }
54353 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54354 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54355 }
54356 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54357 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54358 }
54359 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54360 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54361 }
54362 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54363 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54364 }
54365 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54366 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54367 }
54368 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54369 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54370 }
54371 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54372 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54373 }
54374 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54375 return (void *)((wxObject *) ((wxImageHandler *) x));
54376 }
54377 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54378 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54379 }
54380 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54381 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54382 }
54383 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54384 return (void *)((wxObject *) ((wxEvtHandler *) x));
54385 }
54386 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54387 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54388 }
54389 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54390 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54391 }
54392 static void *_p_wxImageTo_p_wxObject(void *x) {
54393 return (void *)((wxObject *) ((wxImage *) x));
54394 }
54395 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54396 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54397 }
54398 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54399 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54400 }
54401 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54402 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54403 }
54404 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54405 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54406 }
54407 static void *_p_wxWindowTo_p_wxObject(void *x) {
54408 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54409 }
54410 static void *_p_wxMenuTo_p_wxObject(void *x) {
54411 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54412 }
54413 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54414 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54415 }
54416 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54417 return (void *)((wxObject *) ((wxFileSystem *) x));
54418 }
54419 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54420 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54421 }
54422 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54423 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54424 }
54425 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54426 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54427 }
54428 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54429 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54430 }
54431 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54432 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54433 }
54434 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54435 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54436 }
54437 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54438 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54439 }
54440 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54441 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54442 }
54443 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54444 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54445 }
54446 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54447 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54448 }
54449 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54450 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54451 }
54452 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54453 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54454 }
54455 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54456 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54457 }
54458 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54459 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54460 }
54461 static void *_p_wxControlTo_p_wxWindow(void *x) {
54462 return (void *)((wxWindow *) ((wxControl *) x));
54463 }
54464 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54465 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54466 }
54467 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54468 return (void *)((wxWindow *) ((wxMenuBar *) x));
54469 }
54470 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54471 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54472 }
54473 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54474 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54475 }
54476 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54477 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54478 }
54479 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54480 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54481 }
54482 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54483 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54484 }
54485 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54486 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54487 }
54488 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54489 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54490 }
54491 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54492 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54493 }
54494 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54495 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54496 }
54497 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54498 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54499 }
54500 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54501 return (void *)((wxValidator *) ((wxPyValidator *) x));
54502 }
54503 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54504 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54505 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};
54506 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54507 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54508 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54509 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54510 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54511 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54512 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54513 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54514 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54515 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54516 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54517 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54518 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54519 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54520 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54521 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54522 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54523 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54524 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54525 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54526 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54527 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54528 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54529 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54530 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54531 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54532 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54533 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54534 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54535 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54536 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54537 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54538 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54539 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54540 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54541 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54542 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54543 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54544 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54545 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54546 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54547 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54548 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54549 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54550 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54551 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54552 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54553 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54554 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54555 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54556 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54557 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54558 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54559 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54560 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54561 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54562 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54563 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54564 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54565 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54566 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54567 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54568 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54569 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54570 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54571 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54572 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54573 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54574 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54575 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54576 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54577 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54578 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54579 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54580 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54581 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54582 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54583 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54584 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54585 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54586 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54587 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54588 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54589 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54590 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54591 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54592 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54593 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54594 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54595 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54596 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54597 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54598 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54599 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54600 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54601 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54602 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54603 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54604 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54605 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54606 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54607 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54608 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54609 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54610 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54611 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54612 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54613 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54614 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54615 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54616 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54617 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54618 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54619 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54620 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54621 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54622 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54623 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54624 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54625 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54626 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54627 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54628 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54629 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54630 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54631 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54632 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54633
54634 static swig_type_info *swig_type_initial[] = {
54635 &_swigt__p_buffer,
54636 &_swigt__p_char,
54637 &_swigt__p_form_ops_t,
54638 &_swigt__p_int,
54639 &_swigt__p_long,
54640 &_swigt__p_unsigned_char,
54641 &_swigt__p_unsigned_int,
54642 &_swigt__p_unsigned_long,
54643 &_swigt__p_wxANIHandler,
54644 &_swigt__p_wxAcceleratorEntry,
54645 &_swigt__p_wxAcceleratorTable,
54646 &_swigt__p_wxActivateEvent,
54647 &_swigt__p_wxAppTraits,
54648 &_swigt__p_wxArrayString,
54649 &_swigt__p_wxBMPHandler,
54650 &_swigt__p_wxBitmap,
54651 &_swigt__p_wxBoxSizer,
54652 &_swigt__p_wxButton,
54653 &_swigt__p_wxCURHandler,
54654 &_swigt__p_wxCaret,
54655 &_swigt__p_wxChildFocusEvent,
54656 &_swigt__p_wxClipboardTextEvent,
54657 &_swigt__p_wxCloseEvent,
54658 &_swigt__p_wxColour,
54659 &_swigt__p_wxCommandEvent,
54660 &_swigt__p_wxContextMenuEvent,
54661 &_swigt__p_wxControl,
54662 &_swigt__p_wxControlWithItems,
54663 &_swigt__p_wxCursor,
54664 &_swigt__p_wxDC,
54665 &_swigt__p_wxDateEvent,
54666 &_swigt__p_wxDateTime,
54667 &_swigt__p_wxDisplayChangedEvent,
54668 &_swigt__p_wxDropFilesEvent,
54669 &_swigt__p_wxDuplexMode,
54670 &_swigt__p_wxEraseEvent,
54671 &_swigt__p_wxEvent,
54672 &_swigt__p_wxEventLoop,
54673 &_swigt__p_wxEventLoopActivator,
54674 &_swigt__p_wxEvtHandler,
54675 &_swigt__p_wxFSFile,
54676 &_swigt__p_wxFileSystem,
54677 &_swigt__p_wxFileSystemHandler,
54678 &_swigt__p_wxFlexGridSizer,
54679 &_swigt__p_wxFocusEvent,
54680 &_swigt__p_wxFont,
54681 &_swigt__p_wxFrame,
54682 &_swigt__p_wxGBPosition,
54683 &_swigt__p_wxGBSizerItem,
54684 &_swigt__p_wxGBSpan,
54685 &_swigt__p_wxGIFHandler,
54686 &_swigt__p_wxGridBagSizer,
54687 &_swigt__p_wxGridSizer,
54688 &_swigt__p_wxICOHandler,
54689 &_swigt__p_wxIconizeEvent,
54690 &_swigt__p_wxIdleEvent,
54691 &_swigt__p_wxImage,
54692 &_swigt__p_wxImageHandler,
54693 &_swigt__p_wxImageHistogram,
54694 &_swigt__p_wxImage_HSVValue,
54695 &_swigt__p_wxImage_RGBValue,
54696 &_swigt__p_wxIndividualLayoutConstraint,
54697 &_swigt__p_wxInitDialogEvent,
54698 &_swigt__p_wxInputStream,
54699 &_swigt__p_wxInternetFSHandler,
54700 &_swigt__p_wxItemContainer,
54701 &_swigt__p_wxJPEGHandler,
54702 &_swigt__p_wxKeyEvent,
54703 &_swigt__p_wxLayoutConstraints,
54704 &_swigt__p_wxMaximizeEvent,
54705 &_swigt__p_wxMemoryFSHandler,
54706 &_swigt__p_wxMenu,
54707 &_swigt__p_wxMenuBar,
54708 &_swigt__p_wxMenuBarBase,
54709 &_swigt__p_wxMenuEvent,
54710 &_swigt__p_wxMenuItem,
54711 &_swigt__p_wxMouseCaptureChangedEvent,
54712 &_swigt__p_wxMouseEvent,
54713 &_swigt__p_wxMoveEvent,
54714 &_swigt__p_wxNavigationKeyEvent,
54715 &_swigt__p_wxNcPaintEvent,
54716 &_swigt__p_wxNotifyEvent,
54717 &_swigt__p_wxObject,
54718 &_swigt__p_wxOutputStream,
54719 &_swigt__p_wxPCXHandler,
54720 &_swigt__p_wxPNGHandler,
54721 &_swigt__p_wxPNMHandler,
54722 &_swigt__p_wxPaintEvent,
54723 &_swigt__p_wxPaletteChangedEvent,
54724 &_swigt__p_wxPaperSize,
54725 &_swigt__p_wxPoint,
54726 &_swigt__p_wxPoint2D,
54727 &_swigt__p_wxPropagateOnce,
54728 &_swigt__p_wxPropagationDisabler,
54729 &_swigt__p_wxPyApp,
54730 &_swigt__p_wxPyCommandEvent,
54731 &_swigt__p_wxPyDropTarget,
54732 &_swigt__p_wxPyEvent,
54733 &_swigt__p_wxPyFileSystemHandler,
54734 &_swigt__p_wxPyImageHandler,
54735 &_swigt__p_wxPyInputStream,
54736 &_swigt__p_wxPySizer,
54737 &_swigt__p_wxPyValidator,
54738 &_swigt__p_wxQuantize,
54739 &_swigt__p_wxQueryNewPaletteEvent,
54740 &_swigt__p_wxRealPoint,
54741 &_swigt__p_wxRect,
54742 &_swigt__p_wxRegion,
54743 &_swigt__p_wxScrollEvent,
54744 &_swigt__p_wxScrollWinEvent,
54745 &_swigt__p_wxSetCursorEvent,
54746 &_swigt__p_wxShowEvent,
54747 &_swigt__p_wxSize,
54748 &_swigt__p_wxSizeEvent,
54749 &_swigt__p_wxSizer,
54750 &_swigt__p_wxSizerItem,
54751 &_swigt__p_wxStaticBox,
54752 &_swigt__p_wxStaticBoxSizer,
54753 &_swigt__p_wxStdDialogButtonSizer,
54754 &_swigt__p_wxSysColourChangedEvent,
54755 &_swigt__p_wxTIFFHandler,
54756 &_swigt__p_wxToolTip,
54757 &_swigt__p_wxUpdateUIEvent,
54758 &_swigt__p_wxValidator,
54759 &_swigt__p_wxVisualAttributes,
54760 &_swigt__p_wxWindow,
54761 &_swigt__p_wxWindowCreateEvent,
54762 &_swigt__p_wxWindowDestroyEvent,
54763 &_swigt__p_wxXPMHandler,
54764 &_swigt__p_wxZipFSHandler,
54765 };
54766
54767 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54768 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54769 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54770 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54771 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54772 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54773 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54774 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54775 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54776 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54777 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54778 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54779 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54780 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54781 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}};
54782 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54783 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}};
54784 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54785 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}};
54786 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54787 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54788 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
54789 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54790 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54791 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
54792 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54793 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}};
54794 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54795 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54796 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54797 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54798 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54799 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54800 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54801 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54802 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54803 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
54804 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54805 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54806 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}};
54807 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54808 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54809 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}};
54810 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}};
54811 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54812 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54813 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54814 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54815 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54816 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54817 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54818 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54819 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}};
54820 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}};
54821 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54822 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54823 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54824 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}};
54825 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54826 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54827 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54828 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54829 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54830 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54831 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54832 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}};
54833 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54834 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54835 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54836 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54837 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54838 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54839 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54840 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54841 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54842 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54843 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54844 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54845 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54846 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54847 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54848 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54849 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
54850 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54851 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54852 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54853 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54854 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54855 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54856 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54857 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54858 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54859 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54860 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54861 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54862 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54863 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54864 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54865 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54866 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54867 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54868 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54869 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54870 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54871 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54872 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54873 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54874 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54875 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54876 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54877 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54878 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54879 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54880 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54881 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}};
54882 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}};
54883 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54884 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54885 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54886 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54887 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54888 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54889 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54890 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}};
54891 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54892 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}};
54893 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54894 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54895 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54896 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54897
54898 static swig_cast_info *swig_cast_initial[] = {
54899 _swigc__p_buffer,
54900 _swigc__p_char,
54901 _swigc__p_form_ops_t,
54902 _swigc__p_int,
54903 _swigc__p_long,
54904 _swigc__p_unsigned_char,
54905 _swigc__p_unsigned_int,
54906 _swigc__p_unsigned_long,
54907 _swigc__p_wxANIHandler,
54908 _swigc__p_wxAcceleratorEntry,
54909 _swigc__p_wxAcceleratorTable,
54910 _swigc__p_wxActivateEvent,
54911 _swigc__p_wxAppTraits,
54912 _swigc__p_wxArrayString,
54913 _swigc__p_wxBMPHandler,
54914 _swigc__p_wxBitmap,
54915 _swigc__p_wxBoxSizer,
54916 _swigc__p_wxButton,
54917 _swigc__p_wxCURHandler,
54918 _swigc__p_wxCaret,
54919 _swigc__p_wxChildFocusEvent,
54920 _swigc__p_wxClipboardTextEvent,
54921 _swigc__p_wxCloseEvent,
54922 _swigc__p_wxColour,
54923 _swigc__p_wxCommandEvent,
54924 _swigc__p_wxContextMenuEvent,
54925 _swigc__p_wxControl,
54926 _swigc__p_wxControlWithItems,
54927 _swigc__p_wxCursor,
54928 _swigc__p_wxDC,
54929 _swigc__p_wxDateEvent,
54930 _swigc__p_wxDateTime,
54931 _swigc__p_wxDisplayChangedEvent,
54932 _swigc__p_wxDropFilesEvent,
54933 _swigc__p_wxDuplexMode,
54934 _swigc__p_wxEraseEvent,
54935 _swigc__p_wxEvent,
54936 _swigc__p_wxEventLoop,
54937 _swigc__p_wxEventLoopActivator,
54938 _swigc__p_wxEvtHandler,
54939 _swigc__p_wxFSFile,
54940 _swigc__p_wxFileSystem,
54941 _swigc__p_wxFileSystemHandler,
54942 _swigc__p_wxFlexGridSizer,
54943 _swigc__p_wxFocusEvent,
54944 _swigc__p_wxFont,
54945 _swigc__p_wxFrame,
54946 _swigc__p_wxGBPosition,
54947 _swigc__p_wxGBSizerItem,
54948 _swigc__p_wxGBSpan,
54949 _swigc__p_wxGIFHandler,
54950 _swigc__p_wxGridBagSizer,
54951 _swigc__p_wxGridSizer,
54952 _swigc__p_wxICOHandler,
54953 _swigc__p_wxIconizeEvent,
54954 _swigc__p_wxIdleEvent,
54955 _swigc__p_wxImage,
54956 _swigc__p_wxImageHandler,
54957 _swigc__p_wxImageHistogram,
54958 _swigc__p_wxImage_HSVValue,
54959 _swigc__p_wxImage_RGBValue,
54960 _swigc__p_wxIndividualLayoutConstraint,
54961 _swigc__p_wxInitDialogEvent,
54962 _swigc__p_wxInputStream,
54963 _swigc__p_wxInternetFSHandler,
54964 _swigc__p_wxItemContainer,
54965 _swigc__p_wxJPEGHandler,
54966 _swigc__p_wxKeyEvent,
54967 _swigc__p_wxLayoutConstraints,
54968 _swigc__p_wxMaximizeEvent,
54969 _swigc__p_wxMemoryFSHandler,
54970 _swigc__p_wxMenu,
54971 _swigc__p_wxMenuBar,
54972 _swigc__p_wxMenuBarBase,
54973 _swigc__p_wxMenuEvent,
54974 _swigc__p_wxMenuItem,
54975 _swigc__p_wxMouseCaptureChangedEvent,
54976 _swigc__p_wxMouseEvent,
54977 _swigc__p_wxMoveEvent,
54978 _swigc__p_wxNavigationKeyEvent,
54979 _swigc__p_wxNcPaintEvent,
54980 _swigc__p_wxNotifyEvent,
54981 _swigc__p_wxObject,
54982 _swigc__p_wxOutputStream,
54983 _swigc__p_wxPCXHandler,
54984 _swigc__p_wxPNGHandler,
54985 _swigc__p_wxPNMHandler,
54986 _swigc__p_wxPaintEvent,
54987 _swigc__p_wxPaletteChangedEvent,
54988 _swigc__p_wxPaperSize,
54989 _swigc__p_wxPoint,
54990 _swigc__p_wxPoint2D,
54991 _swigc__p_wxPropagateOnce,
54992 _swigc__p_wxPropagationDisabler,
54993 _swigc__p_wxPyApp,
54994 _swigc__p_wxPyCommandEvent,
54995 _swigc__p_wxPyDropTarget,
54996 _swigc__p_wxPyEvent,
54997 _swigc__p_wxPyFileSystemHandler,
54998 _swigc__p_wxPyImageHandler,
54999 _swigc__p_wxPyInputStream,
55000 _swigc__p_wxPySizer,
55001 _swigc__p_wxPyValidator,
55002 _swigc__p_wxQuantize,
55003 _swigc__p_wxQueryNewPaletteEvent,
55004 _swigc__p_wxRealPoint,
55005 _swigc__p_wxRect,
55006 _swigc__p_wxRegion,
55007 _swigc__p_wxScrollEvent,
55008 _swigc__p_wxScrollWinEvent,
55009 _swigc__p_wxSetCursorEvent,
55010 _swigc__p_wxShowEvent,
55011 _swigc__p_wxSize,
55012 _swigc__p_wxSizeEvent,
55013 _swigc__p_wxSizer,
55014 _swigc__p_wxSizerItem,
55015 _swigc__p_wxStaticBox,
55016 _swigc__p_wxStaticBoxSizer,
55017 _swigc__p_wxStdDialogButtonSizer,
55018 _swigc__p_wxSysColourChangedEvent,
55019 _swigc__p_wxTIFFHandler,
55020 _swigc__p_wxToolTip,
55021 _swigc__p_wxUpdateUIEvent,
55022 _swigc__p_wxValidator,
55023 _swigc__p_wxVisualAttributes,
55024 _swigc__p_wxWindow,
55025 _swigc__p_wxWindowCreateEvent,
55026 _swigc__p_wxWindowDestroyEvent,
55027 _swigc__p_wxXPMHandler,
55028 _swigc__p_wxZipFSHandler,
55029 };
55030
55031
55032 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55033
55034 static swig_const_info swig_const_table[] = {
55035 {0, 0, 0, 0.0, 0, 0}};
55036
55037 #ifdef __cplusplus
55038 }
55039 #endif
55040 /* -----------------------------------------------------------------------------
55041 * Type initialization:
55042 * This problem is tough by the requirement that no dynamic
55043 * memory is used. Also, since swig_type_info structures store pointers to
55044 * swig_cast_info structures and swig_cast_info structures store pointers back
55045 * to swig_type_info structures, we need some lookup code at initialization.
55046 * The idea is that swig generates all the structures that are needed.
55047 * The runtime then collects these partially filled structures.
55048 * The SWIG_InitializeModule function takes these initial arrays out of
55049 * swig_module, and does all the lookup, filling in the swig_module.types
55050 * array with the correct data and linking the correct swig_cast_info
55051 * structures together.
55052 *
55053 * The generated swig_type_info structures are assigned staticly to an initial
55054 * array. We just loop though that array, and handle each type individually.
55055 * First we lookup if this type has been already loaded, and if so, use the
55056 * loaded structure instead of the generated one. Then we have to fill in the
55057 * cast linked list. The cast data is initially stored in something like a
55058 * two-dimensional array. Each row corresponds to a type (there are the same
55059 * number of rows as there are in the swig_type_initial array). Each entry in
55060 * a column is one of the swig_cast_info structures for that type.
55061 * The cast_initial array is actually an array of arrays, because each row has
55062 * a variable number of columns. So to actually build the cast linked list,
55063 * we find the array of casts associated with the type, and loop through it
55064 * adding the casts to the list. The one last trick we need to do is making
55065 * sure the type pointer in the swig_cast_info struct is correct.
55066 *
55067 * First off, we lookup the cast->type name to see if it is already loaded.
55068 * There are three cases to handle:
55069 * 1) If the cast->type has already been loaded AND the type we are adding
55070 * casting info to has not been loaded (it is in this module), THEN we
55071 * replace the cast->type pointer with the type pointer that has already
55072 * been loaded.
55073 * 2) If BOTH types (the one we are adding casting info to, and the
55074 * cast->type) are loaded, THEN the cast info has already been loaded by
55075 * the previous module so we just ignore it.
55076 * 3) Finally, if cast->type has not already been loaded, then we add that
55077 * swig_cast_info to the linked list (because the cast->type) pointer will
55078 * be correct.
55079 * ----------------------------------------------------------------------------- */
55080
55081 #ifdef __cplusplus
55082 extern "C" {
55083 #if 0
55084 } /* c-mode */
55085 #endif
55086 #endif
55087
55088 #if 0
55089 #define SWIGRUNTIME_DEBUG
55090 #endif
55091
55092 SWIGRUNTIME void
55093 SWIG_InitializeModule(void *clientdata) {
55094 size_t i;
55095 swig_module_info *module_head;
55096 static int init_run = 0;
55097
55098 clientdata = clientdata;
55099
55100 if (init_run) return;
55101 init_run = 1;
55102
55103 /* Initialize the swig_module */
55104 swig_module.type_initial = swig_type_initial;
55105 swig_module.cast_initial = swig_cast_initial;
55106
55107 /* Try and load any already created modules */
55108 module_head = SWIG_GetModule(clientdata);
55109 if (module_head) {
55110 swig_module.next = module_head->next;
55111 module_head->next = &swig_module;
55112 } else {
55113 /* This is the first module loaded */
55114 swig_module.next = &swig_module;
55115 SWIG_SetModule(clientdata, &swig_module);
55116 }
55117
55118 /* Now work on filling in swig_module.types */
55119 #ifdef SWIGRUNTIME_DEBUG
55120 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55121 #endif
55122 for (i = 0; i < swig_module.size; ++i) {
55123 swig_type_info *type = 0;
55124 swig_type_info *ret;
55125 swig_cast_info *cast;
55126
55127 #ifdef SWIGRUNTIME_DEBUG
55128 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55129 #endif
55130
55131 /* if there is another module already loaded */
55132 if (swig_module.next != &swig_module) {
55133 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55134 }
55135 if (type) {
55136 /* Overwrite clientdata field */
55137 #ifdef SWIGRUNTIME_DEBUG
55138 printf("SWIG_InitializeModule: found type %s\n", type->name);
55139 #endif
55140 if (swig_module.type_initial[i]->clientdata) {
55141 type->clientdata = swig_module.type_initial[i]->clientdata;
55142 #ifdef SWIGRUNTIME_DEBUG
55143 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55144 #endif
55145 }
55146 } else {
55147 type = swig_module.type_initial[i];
55148 }
55149
55150 /* Insert casting types */
55151 cast = swig_module.cast_initial[i];
55152 while (cast->type) {
55153 /* Don't need to add information already in the list */
55154 ret = 0;
55155 #ifdef SWIGRUNTIME_DEBUG
55156 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55157 #endif
55158 if (swig_module.next != &swig_module) {
55159 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55160 #ifdef SWIGRUNTIME_DEBUG
55161 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55162 #endif
55163 }
55164 if (ret) {
55165 if (type == swig_module.type_initial[i]) {
55166 #ifdef SWIGRUNTIME_DEBUG
55167 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55168 #endif
55169 cast->type = ret;
55170 ret = 0;
55171 } else {
55172 /* Check for casting already in the list */
55173 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55174 #ifdef SWIGRUNTIME_DEBUG
55175 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55176 #endif
55177 if (!ocast) ret = 0;
55178 }
55179 }
55180
55181 if (!ret) {
55182 #ifdef SWIGRUNTIME_DEBUG
55183 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55184 #endif
55185 if (type->cast) {
55186 type->cast->prev = cast;
55187 cast->next = type->cast;
55188 }
55189 type->cast = cast;
55190 }
55191 cast++;
55192 }
55193 /* Set entry in modules->types array equal to the type */
55194 swig_module.types[i] = type;
55195 }
55196 swig_module.types[i] = 0;
55197
55198 #ifdef SWIGRUNTIME_DEBUG
55199 printf("**** SWIG_InitializeModule: Cast List ******\n");
55200 for (i = 0; i < swig_module.size; ++i) {
55201 int j = 0;
55202 swig_cast_info *cast = swig_module.cast_initial[i];
55203 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55204 while (cast->type) {
55205 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55206 cast++;
55207 ++j;
55208 }
55209 printf("---- Total casts: %d\n",j);
55210 }
55211 printf("**** SWIG_InitializeModule: Cast List ******\n");
55212 #endif
55213 }
55214
55215 /* This function will propagate the clientdata field of type to
55216 * any new swig_type_info structures that have been added into the list
55217 * of equivalent types. It is like calling
55218 * SWIG_TypeClientData(type, clientdata) a second time.
55219 */
55220 SWIGRUNTIME void
55221 SWIG_PropagateClientData(void) {
55222 size_t i;
55223 swig_cast_info *equiv;
55224 static int init_run = 0;
55225
55226 if (init_run) return;
55227 init_run = 1;
55228
55229 for (i = 0; i < swig_module.size; i++) {
55230 if (swig_module.types[i]->clientdata) {
55231 equiv = swig_module.types[i]->cast;
55232 while (equiv) {
55233 if (!equiv->converter) {
55234 if (equiv->type && !equiv->type->clientdata)
55235 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55236 }
55237 equiv = equiv->next;
55238 }
55239 }
55240 }
55241 }
55242
55243 #ifdef __cplusplus
55244 #if 0
55245 {
55246 /* c-mode */
55247 #endif
55248 }
55249 #endif
55250
55251
55252
55253 #ifdef __cplusplus
55254 extern "C" {
55255 #endif
55256
55257 /* Python-specific SWIG API */
55258 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55259 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55260 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55261
55262 /* -----------------------------------------------------------------------------
55263 * global variable support code.
55264 * ----------------------------------------------------------------------------- */
55265
55266 typedef struct swig_globalvar {
55267 char *name; /* Name of global variable */
55268 PyObject *(*get_attr)(void); /* Return the current value */
55269 int (*set_attr)(PyObject *); /* Set the value */
55270 struct swig_globalvar *next;
55271 } swig_globalvar;
55272
55273 typedef struct swig_varlinkobject {
55274 PyObject_HEAD
55275 swig_globalvar *vars;
55276 } swig_varlinkobject;
55277
55278 SWIGINTERN PyObject *
55279 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55280 return PyString_FromString("<Swig global variables>");
55281 }
55282
55283 SWIGINTERN PyObject *
55284 swig_varlink_str(swig_varlinkobject *v) {
55285 PyObject *str = PyString_FromString("(");
55286 swig_globalvar *var;
55287 for (var = v->vars; var; var=var->next) {
55288 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55289 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55290 }
55291 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55292 return str;
55293 }
55294
55295 SWIGINTERN int
55296 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55297 PyObject *str = swig_varlink_str(v);
55298 fprintf(fp,"Swig global variables ");
55299 fprintf(fp,"%s\n", PyString_AsString(str));
55300 Py_DECREF(str);
55301 return 0;
55302 }
55303
55304 SWIGINTERN void
55305 swig_varlink_dealloc(swig_varlinkobject *v) {
55306 swig_globalvar *var = v->vars;
55307 while (var) {
55308 swig_globalvar *n = var->next;
55309 free(var->name);
55310 free(var);
55311 var = n;
55312 }
55313 }
55314
55315 SWIGINTERN PyObject *
55316 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55317 PyObject *res = NULL;
55318 swig_globalvar *var = v->vars;
55319 while (var) {
55320 if (strcmp(var->name,n) == 0) {
55321 res = (*var->get_attr)();
55322 break;
55323 }
55324 var = var->next;
55325 }
55326 if (res == NULL && !PyErr_Occurred()) {
55327 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55328 }
55329 return res;
55330 }
55331
55332 SWIGINTERN int
55333 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55334 int res = 1;
55335 swig_globalvar *var = v->vars;
55336 while (var) {
55337 if (strcmp(var->name,n) == 0) {
55338 res = (*var->set_attr)(p);
55339 break;
55340 }
55341 var = var->next;
55342 }
55343 if (res == 1 && !PyErr_Occurred()) {
55344 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55345 }
55346 return res;
55347 }
55348
55349 SWIGINTERN PyTypeObject*
55350 swig_varlink_type(void) {
55351 static char varlink__doc__[] = "Swig var link object";
55352 static PyTypeObject varlink_type;
55353 static int type_init = 0;
55354 if (!type_init) {
55355 const PyTypeObject tmp
55356 = {
55357 PyObject_HEAD_INIT(NULL)
55358 0, /* Number of items in variable part (ob_size) */
55359 (char *)"swigvarlink", /* Type name (tp_name) */
55360 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55361 0, /* Itemsize (tp_itemsize) */
55362 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55363 (printfunc) swig_varlink_print, /* Print (tp_print) */
55364 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55365 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55366 0, /* tp_compare */
55367 (reprfunc) swig_varlink_repr, /* tp_repr */
55368 0, /* tp_as_number */
55369 0, /* tp_as_sequence */
55370 0, /* tp_as_mapping */
55371 0, /* tp_hash */
55372 0, /* tp_call */
55373 (reprfunc)swig_varlink_str, /* tp_str */
55374 0, /* tp_getattro */
55375 0, /* tp_setattro */
55376 0, /* tp_as_buffer */
55377 0, /* tp_flags */
55378 varlink__doc__, /* tp_doc */
55379 0, /* tp_traverse */
55380 0, /* tp_clear */
55381 0, /* tp_richcompare */
55382 0, /* tp_weaklistoffset */
55383 #if PY_VERSION_HEX >= 0x02020000
55384 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55385 #endif
55386 #if PY_VERSION_HEX >= 0x02030000
55387 0, /* tp_del */
55388 #endif
55389 #ifdef COUNT_ALLOCS
55390 0,0,0,0 /* tp_alloc -> tp_next */
55391 #endif
55392 };
55393 varlink_type = tmp;
55394 varlink_type.ob_type = &PyType_Type;
55395 type_init = 1;
55396 }
55397 return &varlink_type;
55398 }
55399
55400 /* Create a variable linking object for use later */
55401 SWIGINTERN PyObject *
55402 SWIG_Python_newvarlink(void) {
55403 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55404 if (result) {
55405 result->vars = 0;
55406 }
55407 return ((PyObject*) result);
55408 }
55409
55410 SWIGINTERN void
55411 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55412 swig_varlinkobject *v = (swig_varlinkobject *) p;
55413 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55414 if (gv) {
55415 size_t size = strlen(name)+1;
55416 gv->name = (char *)malloc(size);
55417 if (gv->name) {
55418 strncpy(gv->name,name,size);
55419 gv->get_attr = get_attr;
55420 gv->set_attr = set_attr;
55421 gv->next = v->vars;
55422 }
55423 }
55424 v->vars = gv;
55425 }
55426
55427 SWIGINTERN PyObject *
55428 SWIG_globals() {
55429 static PyObject *_SWIG_globals = 0;
55430 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55431 return _SWIG_globals;
55432 }
55433
55434 /* -----------------------------------------------------------------------------
55435 * constants/methods manipulation
55436 * ----------------------------------------------------------------------------- */
55437
55438 /* Install Constants */
55439 SWIGINTERN void
55440 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55441 PyObject *obj = 0;
55442 size_t i;
55443 for (i = 0; constants[i].type; ++i) {
55444 switch(constants[i].type) {
55445 case SWIG_PY_POINTER:
55446 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55447 break;
55448 case SWIG_PY_BINARY:
55449 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55450 break;
55451 default:
55452 obj = 0;
55453 break;
55454 }
55455 if (obj) {
55456 PyDict_SetItemString(d, constants[i].name, obj);
55457 Py_DECREF(obj);
55458 }
55459 }
55460 }
55461
55462 /* -----------------------------------------------------------------------------*/
55463 /* Fix SwigMethods to carry the callback ptrs when needed */
55464 /* -----------------------------------------------------------------------------*/
55465
55466 SWIGINTERN void
55467 SWIG_Python_FixMethods(PyMethodDef *methods,
55468 swig_const_info *const_table,
55469 swig_type_info **types,
55470 swig_type_info **types_initial) {
55471 size_t i;
55472 for (i = 0; methods[i].ml_name; ++i) {
55473 char *c = methods[i].ml_doc;
55474 if (c && (c = strstr(c, "swig_ptr: "))) {
55475 int j;
55476 swig_const_info *ci = 0;
55477 char *name = c + 10;
55478 for (j = 0; const_table[j].type; ++j) {
55479 if (strncmp(const_table[j].name, name,
55480 strlen(const_table[j].name)) == 0) {
55481 ci = &(const_table[j]);
55482 break;
55483 }
55484 }
55485 if (ci) {
55486 size_t shift = (ci->ptype) - types;
55487 swig_type_info *ty = types_initial[shift];
55488 size_t ldoc = (c - methods[i].ml_doc);
55489 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55490 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55491 if (ndoc) {
55492 char *buff = ndoc;
55493 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55494 if (ptr) {
55495 strncpy(buff, methods[i].ml_doc, ldoc);
55496 buff += ldoc;
55497 strncpy(buff, "swig_ptr: ", 10);
55498 buff += 10;
55499 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55500 methods[i].ml_doc = ndoc;
55501 }
55502 }
55503 }
55504 }
55505 }
55506 }
55507
55508 #ifdef __cplusplus
55509 }
55510 #endif
55511
55512 /* -----------------------------------------------------------------------------*
55513 * Partial Init method
55514 * -----------------------------------------------------------------------------*/
55515
55516 #ifdef __cplusplus
55517 extern "C"
55518 #endif
55519 SWIGEXPORT void SWIG_init(void) {
55520 PyObject *m, *d;
55521
55522 /* Fix SwigMethods to carry the callback ptrs when needed */
55523 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55524
55525 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55526 d = PyModule_GetDict(m);
55527
55528 SWIG_InitializeModule(0);
55529 SWIG_InstallConstants(d,swig_const_table);
55530
55531
55532
55533 #ifndef wxPyUSE_EXPORT
55534 // Make our API structure a CObject so other modules can import it
55535 // from this module.
55536 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55537 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55538 Py_XDECREF(cobj);
55539 #endif
55540
55541 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55542 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55543 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55544 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55545 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55546 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55547 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55548 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55549 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55550 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55551 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55552 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55553 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55554 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55555 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55556 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55557 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55558 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55559 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55560 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55561 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55562 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55563 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55564 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55565 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55566 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55567 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55568 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55569 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55570 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55571 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55572 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55573 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55574 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55575 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55576 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55577 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55578 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55579 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55580 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55581 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55582 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55583 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55584 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55585 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55586 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55587 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55588 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55589 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55590 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55591 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55592 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55593 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55594 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55595 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55596 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55597 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55598 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55599 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55600 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55601 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55602 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55603 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55604 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55605 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55606 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55607 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55608 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55609 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55610 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55611 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55612 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55613 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55614 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55615 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55616 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55617 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55618 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55619 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55620 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55621 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55622 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55623 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55624 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55625 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55626 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55627 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55628 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55629 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55630 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55631 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55632 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55633 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55634 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55635 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55636 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55637 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55638 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55639 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55640 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55641 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55642 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55643 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55644 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55645 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55646 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55647 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55648 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55649 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55650 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55651 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55652 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55653 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55654 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55655 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55656 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55657 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55658 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55659 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55660 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55661 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55662 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55663 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55664 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55665 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55666 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55667 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55668 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55669 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55670 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55671 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55672 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55673 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55674 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55675 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55676 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55677 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55678 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55679 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55680 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55681 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55682 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55683 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55684 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55685 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55686 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55687 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55688 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55689 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55690 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55691 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55692 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55693 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55694 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55695 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55696 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55697 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55698 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55699 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55700 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55701 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55702 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55703 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55704 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55705 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55706 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55707 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55708 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55709 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55710 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55711 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55712 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55713 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55714 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55715 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55716 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55717 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55718 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55719 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55720 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55721 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55722 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55723 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55724 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55725 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55726 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55727 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55728 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55729 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55730 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55731 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55732 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55733 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55734 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55735 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55736 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55737 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55738 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55739 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55740 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55741 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55742 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55743 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55744 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55745 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55746 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55747 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55748 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55749 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55750 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55751 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55752 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55753 SWIG_Python_SetConstant(d, "DD_CHANGE_DIR",SWIG_From_int(static_cast< int >(wxDD_CHANGE_DIR)));
55754 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55755 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55756 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55757 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55758 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55759 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55760 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55761 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55762 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55763 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55764 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55765 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55766 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55767 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55768 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55769 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55770 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55771 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55772 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55773 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55774 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55775 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55776 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55777 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55778 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55779 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55780 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55781 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55782 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55783 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55784 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55785 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55786 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55787 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55788 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55789 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55790 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55791 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55792 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55793 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55794 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55795 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55796 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55797 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55798 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55799 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55800 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55801 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55802 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55803 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55804 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55805 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55806 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55807 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55808 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55809 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55810 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55811 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55812 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55813 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55814 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55815 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55816 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55817 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55818 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55819 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55820 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55821 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55822 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55823 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55824 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55825 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55826 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55827 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55828 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55829 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55830 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55831 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55832 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55833 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55834 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55835 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55836 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55837 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55838 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55839 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55840 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55841 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55842 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55843 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55844 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55845 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55846 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55847 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55848 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55849 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55850 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55851 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55852 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55853 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55854 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55855 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55856 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55857 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55858 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55859 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55860 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55861 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55862 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55863 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55864 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55865 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55866 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55867 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55868 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55869 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55870 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55871 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55872 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55873 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55874 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55875 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55876 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55877 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55878 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55879 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55880 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55881 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55882 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55883 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55884 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55885 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55886 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55887 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55888 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55889 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55890 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55891 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55892 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55893 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55894 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55895 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55896 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55897 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55898 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55899 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55900 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55901 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55902 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55903 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55904 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55905 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55906 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55907 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55908 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55909 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55910 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55911 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55912 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55913 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55914 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55915 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55916 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55917 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55918 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55919 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55920 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55921 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55922 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55923 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55924 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55925 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55926 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55927 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55928 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55929 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55930 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55931 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55932 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55933 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55934 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55935 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55936 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55937 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55938 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55939 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55940 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55941 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55942 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55943 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55944 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55945 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55946 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55947 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55948 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55949 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55950 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55951 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55952 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55953 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55954 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55955 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55956 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55957 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55958 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55959 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55960 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55961 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55962 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55963 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55964 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55965 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55966 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55967 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55968 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55969 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55970 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55971 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55972 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55973 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55974 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55975 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55976 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55977 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55978 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55979 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55980 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55981 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55982 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55983 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55984 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55985 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55986 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55987 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55988 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55989 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55990 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55991 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55992 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55993 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55994 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55995 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55996 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55997 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55998 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55999 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56000 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56001 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56002 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56003 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56004 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56005 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56006 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56007 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56008 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56009 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56010 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56011 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56012 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56013 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56014 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56015 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56016 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56017 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56018 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56019 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56020 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56021 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56022 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56023 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56024 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56025 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56026 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56027 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56028 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56029 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56030 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56031 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56032 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56033 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56034 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56035 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56036 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56037 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56038 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56039 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56040 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56041 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56042 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56043 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56044 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56045 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56046 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56047 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56048 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56049 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56050 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56051 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56052 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56053 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56054 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56055 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56056 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56057 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56058 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56059 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56060 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56061 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56062 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56063 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56064 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56065 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56066 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56067 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56068 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56069 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56070 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56071 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56072 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56073 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56074 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56075 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56076 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56077 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56078 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56079 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56080 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56081 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56082 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56083 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56084 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56085 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56086 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56087 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56088 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56089 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56090 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56091 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56092 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56093 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56094 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56095 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56096 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56097 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56098 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56099 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56100 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56101 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56102 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56103 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56104 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56105 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56106 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56107 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56108 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56109 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56110 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56111 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56112 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56113 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56114 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56115 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56116 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56117 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56118 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56119 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56120 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56121 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56122 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56123 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56124 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56125 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56126 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56127 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56128 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56129 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56130 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56131 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56132 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56133 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56134 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56135 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56136 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56137 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56138 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56139 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56140 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56141 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56142 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56143 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56144 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56145 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56146 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56147 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56148 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56149 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56150 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56151 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56152 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56153 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56154 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56155 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56156 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56157 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56158 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56159 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56160 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56161 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56162 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56163 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56164 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56165 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56166 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56167 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56168 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56169 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56170 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56171 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56172 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56173 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56174 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56175 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56176 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56177 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56178 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56179 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56180 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56181 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56182 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56183 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56184 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56185 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56186 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56187 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56188 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56189 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56190 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56191 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56192 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56193 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56194 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56195 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56196 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56197 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56198 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56199 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56200 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56201 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56202 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56203 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56204 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56205 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56206 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56207 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56208 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56209 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56210 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56211 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56212 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56213
56214 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56215
56216
56217 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56218
56219 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56220 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56221 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56222 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56223 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56224 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56225 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56226 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56227 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56228 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56229 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56230 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56231 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56232 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56233 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56234 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56235 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56236 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56237 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56238 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56239 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56240 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56241 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56242 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56243 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56244 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56245 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56246 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56247 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56248 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56249 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56250 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56251 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56252 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56253 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56254 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56255 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56256 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56257 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56258 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56259 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56260 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56261 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56262 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56263 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56264 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56265 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56266 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56267 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56268 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56269 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56270 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56271 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56272 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56273 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56274 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56275 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56276 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56277 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56278 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56279 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56280 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56281 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56282 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56283 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56284 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56285 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56286 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56287 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56288 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56289 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56290 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56291 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56292 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56293 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56294 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56295 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56296 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56297 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56298 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56299 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56300 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56301 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56302 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56303 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56304 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56305 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56306 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56307 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56308 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56309 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56310 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56311 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56312 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56313 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56314 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56315 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56316 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56317 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56318 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56319 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56320 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56321 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56322 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56323 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56324 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56325 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56326 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56327 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56328 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56329 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56330 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56331 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56332 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56333 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56334 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56335 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56336 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56337 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56338 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56339 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56340 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56341 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56342 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56343 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56344 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56345 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56346 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56347 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56348 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56349 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56350 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56351 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56352 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56353 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56354 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56355 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56356 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56357 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56358 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56359 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56360 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56361 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56362 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56363 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56364 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56365 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56366 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56367 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56368 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56369 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56370 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56371 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56372 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56373 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56374 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56375 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56376 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56377 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56378 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56379 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56380 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56381 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56382 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56383 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56384 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56385 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56386 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56387 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56388 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56389 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56390 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56391 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56392 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56393 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56394 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56395 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56396 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56397 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56398 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56399 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56400 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56401 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56402 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56403 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56404 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56405 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56406 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56407 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56408 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56409 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56410 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56411 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56412 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56413 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56414 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56415 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56416 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56417 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56418 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56419 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56420 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56421 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56422 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56423 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56424 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56425 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56426
56427 // Initialize threading, some globals and such
56428 __wxPyPreStart(d);
56429
56430
56431 // Although these are defined in __version__ they need to be here too so
56432 // that an assert can be done to ensure that the wxPython and the wxWindows
56433 // versions match.
56434 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56435 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56436 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56437
56438 }
56439
wxWidgets (Impactor)