]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp,
2893
2894 wxArrayDouble2PyList_helper,
2895 wxPoint2D_LIST_helper
2896 };
2897
2898 #endif
2899
2900
2901 #if !WXWIN_COMPATIBILITY_2_4
2902 #define wxHIDE_READONLY 0
2903 #endif
2904
2905
2906 #define SWIG_From_long PyInt_FromLong
2907
2908
2909 SWIGINTERNINLINE PyObject *
2910 SWIG_From_int (int value)
2911 {
2912 return SWIG_From_long (value);
2913 }
2914
2915 static const wxString wxPyEmptyString(wxEmptyString);
2916 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2917 return self->GetClassInfo()->GetClassName();
2918 }
2919 SWIGINTERN void wxObject_Destroy(wxObject *self){
2920 delete self;
2921 }
2922
2923 #ifndef __WXMAC__
2924 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2925 #endif
2926
2927
2928 #include <limits.h>
2929 #ifndef LLONG_MIN
2930 # define LLONG_MIN LONG_LONG_MIN
2931 #endif
2932 #ifndef LLONG_MAX
2933 # define LLONG_MAX LONG_LONG_MAX
2934 #endif
2935 #ifndef ULLONG_MAX
2936 # define ULLONG_MAX ULONG_LONG_MAX
2937 #endif
2938
2939
2940 SWIGINTERN int
2941 SWIG_AsVal_long (PyObject* obj, long* val)
2942 {
2943 if (PyNumber_Check(obj)) {
2944 if (val) *val = PyInt_AsLong(obj);
2945 return SWIG_OK;
2946 }
2947 return SWIG_TypeError;
2948 }
2949
2950
2951 SWIGINTERN int
2952 SWIG_AsVal_int (PyObject * obj, int *val)
2953 {
2954 long v;
2955 int res = SWIG_AsVal_long (obj, &v);
2956 if (SWIG_IsOK(res)) {
2957 if ((v < INT_MIN || v > INT_MAX)) {
2958 return SWIG_OverflowError;
2959 } else {
2960 if (val) *val = static_cast< int >(v);
2961 }
2962 }
2963 return res;
2964 }
2965
2966 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2967 wxSize temp, *obj = &temp;
2968 if ( other == Py_None ) return false;
2969 if ( ! wxSize_helper(other, &obj) ) {
2970 PyErr_Clear();
2971 return false;
2972 }
2973 return self->operator==(*obj);
2974 }
2975 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2976 wxSize temp, *obj = &temp;
2977 if ( other == Py_None ) return true;
2978 if ( ! wxSize_helper(other, &obj)) {
2979 PyErr_Clear();
2980 return true;
2981 }
2982 return self->operator!=(*obj);
2983 }
2984
2985 #include <float.h>
2986
2987
2988 SWIGINTERN int
2989 SWIG_AsVal_double (PyObject *obj, double* val)
2990 {
2991 if (PyNumber_Check(obj)) {
2992 if (val) *val = PyFloat_AsDouble(obj);
2993 return SWIG_OK;
2994 }
2995 return SWIG_TypeError;
2996 }
2997
2998
2999 SWIGINTERN int
3000 SWIG_AsVal_float (PyObject * obj, float *val)
3001 {
3002 double v;
3003 int res = SWIG_AsVal_double (obj, &v);
3004 if (SWIG_IsOK(res)) {
3005 if ((v < -FLT_MAX || v > FLT_MAX)) {
3006 return SWIG_OverflowError;
3007 } else {
3008 if (val) *val = static_cast< float >(v);
3009 }
3010 }
3011 return res;
3012 }
3013
3014 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3015 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3016 PyObject* tup = PyTuple_New(2);
3017 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3018 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3019 wxPyEndBlockThreads(blocked);
3020 return tup;
3021 }
3022
3023 #define SWIG_From_double PyFloat_FromDouble
3024
3025 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3026 wxRealPoint temp, *obj = &temp;
3027 if ( other == Py_None ) return false;
3028 if ( ! wxRealPoint_helper(other, &obj) ) {
3029 PyErr_Clear();
3030 return false;
3031 }
3032 return self->operator==(*obj);
3033 }
3034 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3035 wxRealPoint temp, *obj = &temp;
3036 if ( other == Py_None ) return true;
3037 if ( ! wxRealPoint_helper(other, &obj)) {
3038 PyErr_Clear();
3039 return true;
3040 }
3041 return self->operator!=(*obj);
3042 }
3043 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3044 self->x = x;
3045 self->y = y;
3046 }
3047 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3048 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3049 PyObject* tup = PyTuple_New(2);
3050 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3051 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3052 wxPyEndBlockThreads(blocked);
3053 return tup;
3054 }
3055 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3056 wxPoint temp, *obj = &temp;
3057 if ( other == Py_None ) return false;
3058 if ( ! wxPoint_helper(other, &obj) ) {
3059 PyErr_Clear();
3060 return false;
3061 }
3062 return self->operator==(*obj);
3063 }
3064 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3065 wxPoint temp, *obj = &temp;
3066 if ( other == Py_None ) return true;
3067 if ( ! wxPoint_helper(other, &obj)) {
3068 PyErr_Clear();
3069 return true;
3070 }
3071 return self->operator!=(*obj);
3072 }
3073 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3074 self->x = x;
3075 self->y = y;
3076 }
3077 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3078 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3079 PyObject* tup = PyTuple_New(2);
3080 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3081 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3082 wxPyEndBlockThreads(blocked);
3083 return tup;
3084 }
3085 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3086 wxRect temp, *obj = &temp;
3087 if ( other == Py_None ) return false;
3088 if ( ! wxRect_helper(other, &obj) ) {
3089 PyErr_Clear();
3090 return false;
3091 }
3092 return self->operator==(*obj);
3093 }
3094 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3095 wxRect temp, *obj = &temp;
3096 if ( other == Py_None ) return true;
3097 if ( ! wxRect_helper(other, &obj)) {
3098 PyErr_Clear();
3099 return true;
3100 }
3101 return self->operator!=(*obj);
3102 }
3103 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3104 self->x = x;
3105 self->y = y;
3106 self->width = width;
3107 self->height = height;
3108 }
3109 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3110 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3111 PyObject* tup = PyTuple_New(4);
3112 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3113 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3114 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3115 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3116 wxPyEndBlockThreads(blocked);
3117 return tup;
3118 }
3119
3120 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3121 wxRegion reg1(*r1);
3122 wxRegion reg2(*r2);
3123 wxRect dest(0,0,0,0);
3124 PyObject* obj;
3125
3126 reg1.Intersect(reg2);
3127 dest = reg1.GetBox();
3128
3129 if (dest != wxRect(0,0,0,0)) {
3130 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3131 wxRect* newRect = new wxRect(dest);
3132 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3133 wxPyEndBlockThreads(blocked);
3134 return obj;
3135 }
3136 Py_INCREF(Py_None);
3137 return Py_None;
3138 }
3139
3140 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3141 wxPoint2D temp, *obj = &temp;
3142 if ( other == Py_None ) return false;
3143 if ( ! wxPoint2D_helper(other, &obj) ) {
3144 PyErr_Clear();
3145 return false;
3146 }
3147 return self->operator==(*obj);
3148 }
3149 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3150 wxPoint2D temp, *obj = &temp;
3151 if ( other == Py_None ) return true;
3152 if ( ! wxPoint2D_helper(other, &obj)) {
3153 PyErr_Clear();
3154 return true;
3155 }
3156 return self->operator!=(*obj);
3157 }
3158 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3159 self->m_x = x;
3160 self->m_y = y;
3161 }
3162 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3163 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3164 PyObject* tup = PyTuple_New(2);
3165 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3166 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3167 wxPyEndBlockThreads(blocked);
3168 return tup;
3169 }
3170
3171 #include "wx/wxPython/pyistream.h"
3172
3173 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3174 wxInputStream* wxis = wxPyCBInputStream::create(p);
3175 if (wxis)
3176 return new wxPyInputStream(wxis);
3177 else
3178 return NULL;
3179 }
3180
3181 SWIGINTERN swig_type_info*
3182 SWIG_pchar_descriptor()
3183 {
3184 static int init = 0;
3185 static swig_type_info* info = 0;
3186 if (!init) {
3187 info = SWIG_TypeQuery("_p_char");
3188 init = 1;
3189 }
3190 return info;
3191 }
3192
3193
3194 SWIGINTERNINLINE PyObject *
3195 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3196 {
3197 if (carray) {
3198 if (size > INT_MAX) {
3199 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3200 return pchar_descriptor ?
3201 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3202 } else {
3203 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3204 }
3205 } else {
3206 return SWIG_Py_Void();
3207 }
3208 }
3209
3210
3211 SWIGINTERNINLINE PyObject *
3212 SWIG_From_char (char c)
3213 {
3214 return SWIG_FromCharPtrAndSize(&c,1);
3215 }
3216
3217
3218 SWIGINTERNINLINE PyObject*
3219 SWIG_From_unsigned_SS_long (unsigned long value)
3220 {
3221 return (value > LONG_MAX) ?
3222 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3223 }
3224
3225
3226 SWIGINTERNINLINE PyObject *
3227 SWIG_From_size_t (size_t value)
3228 {
3229 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3230 }
3231
3232
3233 SWIGINTERN int
3234 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3235 {
3236 if (PyString_Check(obj)) {
3237 char *cstr; Py_ssize_t len;
3238 PyString_AsStringAndSize(obj, &cstr, &len);
3239 if (cptr) {
3240 if (alloc) {
3241 /*
3242 In python the user should not be able to modify the inner
3243 string representation. To warranty that, if you define
3244 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3245 buffer is always returned.
3246
3247 The default behavior is just to return the pointer value,
3248 so, be careful.
3249 */
3250 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3251 if (*alloc != SWIG_OLDOBJ)
3252 #else
3253 if (*alloc == SWIG_NEWOBJ)
3254 #endif
3255 {
3256 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3257 *alloc = SWIG_NEWOBJ;
3258 }
3259 else {
3260 *cptr = cstr;
3261 *alloc = SWIG_OLDOBJ;
3262 }
3263 } else {
3264 *cptr = PyString_AsString(obj);
3265 }
3266 }
3267 if (psize) *psize = len + 1;
3268 return SWIG_OK;
3269 } else {
3270 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3271 if (pchar_descriptor) {
3272 void* vptr = 0;
3273 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3274 if (cptr) *cptr = (char *) vptr;
3275 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3276 if (alloc) *alloc = SWIG_OLDOBJ;
3277 return SWIG_OK;
3278 }
3279 }
3280 }
3281 return SWIG_TypeError;
3282 }
3283
3284
3285 SWIGINTERN int
3286 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3287 {
3288 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3289 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3290 if (SWIG_IsOK(res)) {
3291 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3292 if (csize <= size) {
3293 if (val) {
3294 if (csize) memcpy(val, cptr, csize*sizeof(char));
3295 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3296 }
3297 if (alloc == SWIG_NEWOBJ) {
3298 delete[] cptr;
3299 res = SWIG_DelNewMask(res);
3300 }
3301 return res;
3302 }
3303 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3304 }
3305 return SWIG_TypeError;
3306 }
3307
3308
3309 SWIGINTERN int
3310 SWIG_AsVal_char (PyObject * obj, char *val)
3311 {
3312 int res = SWIG_AsCharArray(obj, val, 1);
3313 if (!SWIG_IsOK(res)) {
3314 long v;
3315 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3316 if (SWIG_IsOK(res)) {
3317 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3318 if (val) *val = static_cast< char >(v);
3319 } else {
3320 res = SWIG_OverflowError;
3321 }
3322 }
3323 }
3324 return res;
3325 }
3326
3327 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3328 // We use only strings for the streams, not unicode
3329 PyObject* str = PyObject_Str(obj);
3330 if (! str) {
3331 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3332 return;
3333 }
3334 self->Write(PyString_AS_STRING(str),
3335 PyString_GET_SIZE(str));
3336 Py_DECREF(str);
3337 }
3338
3339 #include "wx/wxPython/pyistream.h"
3340
3341
3342 class wxPyFileSystemHandler : public wxFileSystemHandler
3343 {
3344 public:
3345 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3346
3347 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3348 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3349 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3350 DEC_PYCALLBACK_STRING__pure(FindNext);
3351
3352 wxString GetProtocol(const wxString& location) {
3353 return wxFileSystemHandler::GetProtocol(location);
3354 }
3355
3356 wxString GetLeftLocation(const wxString& location) {
3357 return wxFileSystemHandler::GetLeftLocation(location);
3358 }
3359
3360 wxString GetAnchor(const wxString& location) {
3361 return wxFileSystemHandler::GetAnchor(location);
3362 }
3363
3364 wxString GetRightLocation(const wxString& location) {
3365 return wxFileSystemHandler::GetRightLocation(location);
3366 }
3367
3368 wxString GetMimeTypeFromExt(const wxString& location) {
3369 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3370 }
3371
3372 PYPRIVATE;
3373 };
3374
3375
3376 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3377 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3378 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3379 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3380
3381
3382 SWIGINTERN int
3383 SWIG_AsVal_bool (PyObject *obj, bool *val)
3384 {
3385 if (obj == Py_True) {
3386 if (val) *val = true;
3387 return SWIG_OK;
3388 } else if (obj == Py_False) {
3389 if (val) *val = false;
3390 return SWIG_OK;
3391 } else {
3392 long v = 0;
3393 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3394 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3395 return res;
3396 }
3397 }
3398
3399 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3400 wxFileName fname = wxFileSystem::URLToFileName(url);
3401 return fname.GetFullPath();
3402 }
3403
3404 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3405 wxImage& image,
3406 long type) {
3407 wxMemoryFSHandler::AddFile(filename, image, type);
3408 }
3409
3410 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3411 const wxBitmap& bitmap,
3412 long type) {
3413 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3414 }
3415
3416 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3417 PyObject* data) {
3418 if (! PyString_Check(data)) {
3419 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3420 "Expected string object"));
3421 return;
3422 }
3423
3424 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3425 void* ptr = (void*)PyString_AsString(data);
3426 size_t size = PyString_Size(data);
3427 wxPyEndBlockThreads(blocked);
3428
3429 wxMemoryFSHandler::AddFile(filename, ptr, size);
3430 }
3431
3432
3433 #include "wx/wxPython/pyistream.h"
3434
3435
3436 SWIGINTERN int
3437 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3438 {
3439 long v = 0;
3440 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3441 return SWIG_TypeError;
3442 }
3443 else if (val)
3444 *val = (unsigned long)v;
3445 return SWIG_OK;
3446 }
3447
3448
3449 SWIGINTERN int
3450 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3451 {
3452 unsigned long v;
3453 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3454 if (SWIG_IsOK(res)) {
3455 if ((v > UCHAR_MAX)) {
3456 return SWIG_OverflowError;
3457 } else {
3458 if (val) *val = static_cast< unsigned char >(v);
3459 }
3460 }
3461 return res;
3462 }
3463
3464
3465 SWIGINTERNINLINE PyObject *
3466 SWIG_From_unsigned_SS_char (unsigned char value)
3467 {
3468 return SWIG_From_unsigned_SS_long (value);
3469 }
3470
3471 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3472 wxImageHistogramEntry e = (*self)[key];
3473 return e.value;
3474 }
3475 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3476 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3477 wxImageHistogramEntry e = (*self)[key];
3478 return e.value;
3479 }
3480 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3481 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3482 colour.Green(),
3483 colour.Blue());
3484 wxImageHistogramEntry e = (*self)[key];
3485 return e.value;
3486 }
3487
3488 // Pull the nested class out to the top level for SWIG's sake
3489 #define wxImage_RGBValue wxImage::RGBValue
3490 #define wxImage_HSVValue wxImage::HSVValue
3491
3492 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3493 if (width > 0 && height > 0)
3494 return new wxImage(width, height, clear);
3495 else
3496 return new wxImage;
3497 }
3498 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3499 return new wxImage(bitmap.ConvertToImage());
3500 }
3501 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3502 if (DATASIZE != width*height*3) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer copy = (buffer)malloc(DATASIZE);
3509 if (copy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(copy, data, DATASIZE);
3514 return new wxImage(width, height, copy, false);
3515 }
3516 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3517 if (DATASIZE != width*height*3) {
3518 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3519 return NULL;
3520 }
3521 if (ALPHASIZE != width*height) {
3522 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3523 return NULL;
3524 }
3525
3526 // Copy the source data so the wxImage can clean it up later
3527 buffer dcopy = (buffer)malloc(DATASIZE);
3528 if (dcopy == NULL) {
3529 wxPyBLOCK_THREADS(PyErr_NoMemory());
3530 return NULL;
3531 }
3532 memcpy(dcopy, data, DATASIZE);
3533
3534 buffer acopy = (buffer)malloc(ALPHASIZE);
3535 if (acopy == NULL) {
3536 wxPyBLOCK_THREADS(PyErr_NoMemory());
3537 return NULL;
3538 }
3539 memcpy(acopy, alpha, ALPHASIZE);
3540
3541 return new wxImage(width, height, dcopy, acopy, false);
3542 }
3543 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3544 wxSize size(self->GetWidth(), self->GetHeight());
3545 return size;
3546 }
3547 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3548 buffer data = self->GetData();
3549 int len = self->GetWidth() * self->GetHeight() * 3;
3550 PyObject* rv;
3551 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3552 return rv;
3553 }
3554 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3555 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3556 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3557 return;
3558 }
3559 buffer copy = (buffer)malloc(DATASIZE);
3560 if (copy == NULL) {
3561 wxPyBLOCK_THREADS(PyErr_NoMemory());
3562 return;
3563 }
3564 memcpy(copy, data, DATASIZE);
3565 self->SetData(copy, false);
3566 // wxImage takes ownership of copy...
3567 }
3568 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3569 buffer data = self->GetData();
3570 int len = self->GetWidth() * self->GetHeight() * 3;
3571 PyObject* rv;
3572 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3573 return rv;
3574 }
3575 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3576 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3577 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3578 return;
3579 }
3580 self->SetData(data, true);
3581 }
3582 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3583 buffer data = self->GetAlpha();
3584 if (! data) {
3585 RETURN_NONE();
3586 } else {
3587 int len = self->GetWidth() * self->GetHeight();
3588 PyObject* rv;
3589 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3590 return rv;
3591 }
3592 }
3593 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3594 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3596 return;
3597 }
3598 buffer acopy = (buffer)malloc(ALPHASIZE);
3599 if (acopy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(acopy, alpha, ALPHASIZE);
3604 self->SetAlpha(acopy, false);
3605 // wxImage takes ownership of acopy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3608 buffer data = self->GetAlpha();
3609 int len = self->GetWidth() * self->GetHeight();
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3615 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3617 return;
3618 }
3619 self->SetAlpha(alpha, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetHandlers(){
3622 wxList& list = wxImage::GetHandlers();
3623 return wxPy_ConvertList(&list);
3624 }
3625 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3626 wxBitmap bitmap(*self, depth);
3627 return bitmap;
3628 }
3629 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3630 wxImage mono = self->ConvertToMono( red, green, blue );
3631 wxBitmap bitmap( mono, 1 );
3632 return bitmap;
3633 }
3634
3635 wxImage* _ImageFromBuffer(int width, int height,
3636 buffer data, int DATASIZE,
3637 buffer alpha=NULL, int ALPHASIZE=0)
3638 {
3639 if (DATASIZE != width*height*3) {
3640 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3641 return NULL;
3642 }
3643 if (alpha != NULL) {
3644 if (ALPHASIZE != width*height) {
3645 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3646 return NULL;
3647 }
3648 return new wxImage(width, height, data, alpha, true);
3649 }
3650 return new wxImage(width, height, data, true);
3651 }
3652
3653 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3654 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3655 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3656 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3659 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3660 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3661 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3662 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3663 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3664 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3665 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3666 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3667 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3668
3669 #include <wx/quantize.h>
3670
3671 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3672 return wxQuantize::Quantize(src, dest,
3673 //NULL, // palette
3674 desiredNoColours,
3675 NULL, // eightBitData
3676 flags);
3677 }
3678 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3679 if (PyCallable_Check(func)) {
3680 self->Connect(id, lastId, eventType,
3681 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3682 new wxPyCallback(func));
3683 }
3684 else if (func == Py_None) {
3685 self->Disconnect(id, lastId, eventType,
3686 (wxObjectEventFunction)
3687 &wxPyCallback::EventThunker);
3688 }
3689 else {
3690 wxPyBLOCK_THREADS(
3691 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3692 }
3693 }
3694 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3695 return self->Disconnect(id, lastId, eventType,
3696 (wxObjectEventFunction)
3697 &wxPyCallback::EventThunker);
3698 }
3699 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3700 if (_self && _self != Py_None) {
3701 self->SetClientObject(new wxPyOORClientData(_self, incref));
3702 }
3703 else {
3704 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3705 if (data) {
3706 self->SetClientObject(NULL); // This will delete it too
3707 }
3708 }
3709 }
3710
3711 #if ! wxUSE_HOTKEY
3712 #define wxEVT_HOTKEY -9999
3713 #endif
3714
3715 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3716 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3717 if (data) {
3718 Py_INCREF(data->m_obj);
3719 return data->m_obj;
3720 } else {
3721 Py_INCREF(Py_None);
3722 return Py_None;
3723 }
3724 }
3725 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3726 wxPyClientData* data = new wxPyClientData(clientData);
3727 self->SetClientObject(data);
3728 }
3729 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3730 #if wxUSE_UNICODE
3731 return self->GetUnicodeKey();
3732 #else
3733 return 0;
3734 #endif
3735 }
3736 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3737 #if wxUSE_UNICODE
3738 self->m_uniChar = uniChar;
3739 #endif
3740 }
3741
3742 SWIGINTERNINLINE PyObject *
3743 SWIG_From_unsigned_SS_int (unsigned int value)
3744 {
3745 return SWIG_From_unsigned_SS_long (value);
3746 }
3747
3748
3749 SWIGINTERN int
3750 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3751 {
3752 unsigned long v;
3753 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3754 if (SWIG_IsOK(res)) {
3755 if ((v > UINT_MAX)) {
3756 return SWIG_OverflowError;
3757 } else {
3758 if (val) *val = static_cast< unsigned int >(v);
3759 }
3760 }
3761 return res;
3762 }
3763
3764 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3765 self->m_size = size;
3766 }
3767 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3768 int count = self->GetNumberOfFiles();
3769 wxString* files = self->GetFiles();
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 PyObject* list = PyList_New(count);
3772
3773 if (!list) {
3774 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3775 wxPyEndBlockThreads(blocked);
3776 return NULL;
3777 }
3778
3779 for (int i=0; i<count; i++) {
3780 PyList_SetItem(list, i, wx2PyString(files[i]));
3781 }
3782 wxPyEndBlockThreads(blocked);
3783 return list;
3784 }
3785
3786
3787 SWIGINTERN wxPyApp *new_wxPyApp(){
3788 wxPythonApp = new wxPyApp();
3789 return wxPythonApp;
3790 }
3791 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3792 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3793 return wxPyTestDisplayAvailable();
3794 }
3795
3796 void wxApp_CleanUp() {
3797 __wxPyCleanup();
3798 }
3799
3800
3801 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3802
3803
3804
3805
3806
3807 SWIGINTERNINLINE PyObject *
3808 SWIG_FromCharPtr(const char *cptr)
3809 {
3810 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3811 }
3812
3813
3814 #if 0 // #ifdef __WXMAC__
3815
3816 // A dummy class that raises an exception if used...
3817 class wxEventLoop
3818 {
3819 public:
3820 wxEventLoop() { wxPyRaiseNotImplemented(); }
3821 int Run() { return 0; }
3822 void Exit(int rc = 0) {}
3823 bool Pending() const { return false; }
3824 bool Dispatch() { return false; }
3825 bool IsRunning() const { return false; }
3826 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3827 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3828 };
3829
3830 #else
3831
3832 #include <wx/evtloop.h>
3833
3834 #endif
3835
3836
3837
3838 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3839 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3840 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3841 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3842 wxWindowList& list = self->GetChildren();
3843 return wxPy_ConvertList(&list);
3844 }
3845 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3846 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3847 #if wxUSE_HOTKEY
3848 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3849 #else
3850 return false;
3851 #endif
3852 }
3853 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3854
3855
3856
3857 return false;
3858
3859 }
3860 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3861 return wxPyGetWinHandle(self);
3862 }
3863 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3864 self->AssociateHandle((WXWidget)handle);
3865 }
3866 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3867
3868 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3869 return wxWindow::FindWindowById(id, parent);
3870 }
3871
3872 wxWindow* wxFindWindowByName( const wxString& name,
3873 const wxWindow *parent = NULL ) {
3874 return wxWindow::FindWindowByName(name, parent);
3875 }
3876
3877 wxWindow* wxFindWindowByLabel( const wxString& label,
3878 const wxWindow *parent = NULL ) {
3879 return wxWindow::FindWindowByLabel(label, parent);
3880 }
3881
3882
3883 #ifdef __WXMSW__
3884 #include <wx/msw/private.h> // to get wxGetWindowId
3885 #endif
3886
3887
3888 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3889 #ifdef __WXMSW__
3890 WXHWND hWnd = (WXHWND)_hWnd;
3891 long id = wxGetWindowId(hWnd);
3892 wxWindow* win = new wxWindow;
3893 if (parent)
3894 parent->AddChild(win);
3895 win->SetEventHandler(win);
3896 win->SetHWND(hWnd);
3897 win->SetId(id);
3898 win->SubclassWin(hWnd);
3899 win->AdoptAttributesFromHWND();
3900 win->SetupColours();
3901 return win;
3902 #else
3903 wxPyRaiseNotImplemented();
3904 return NULL;
3905 #endif
3906 }
3907
3908
3909 PyObject* GetTopLevelWindows() {
3910 return wxPy_ConvertList(&wxTopLevelWindows);
3911 }
3912
3913
3914 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3915 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3916 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3917
3918 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3919
3920
3921 SWIGINTERNINLINE int
3922 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3923 {
3924 unsigned long v;
3925 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3926 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3927 return res;
3928 }
3929
3930 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3931 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3932 wxMenuItemList& list = self->GetMenuItems();
3933 return wxPy_ConvertList(&list);
3934 }
3935 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3936 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3937 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3938 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3939 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3940 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3941 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3942 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3943 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3944 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3945 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3946 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3947 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3948 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3949 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3950 static const wxString wxPyControlNameStr(wxControlNameStr);
3951 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3952 if (clientData) {
3953 wxPyClientData* data = new wxPyClientData(clientData);
3954 return self->Append(item, data);
3955 } else
3956 return self->Append(item);
3957 }
3958 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3959 if (clientData) {
3960 wxPyClientData* data = new wxPyClientData(clientData);
3961 return self->Insert(item, pos, data);
3962 } else
3963 return self->Insert(item, pos);
3964 }
3965 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3966 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3967 if (data) {
3968 Py_INCREF(data->m_obj);
3969 return data->m_obj;
3970 } else {
3971 Py_INCREF(Py_None);
3972 return Py_None;
3973 }
3974 }
3975 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3976 wxPyClientData* data = new wxPyClientData(clientData);
3977 self->SetClientObject(n, data);
3978 }
3979
3980
3981 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3982 wxPyUserData* data = NULL;
3983 if ( userData ) {
3984 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3985 data = new wxPyUserData(userData);
3986 wxPyEndBlockThreads(blocked);
3987 }
3988 return new wxSizerItem(window, proportion, flag, border, data);
3989 }
3990 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3991 wxPyUserData* data = NULL;
3992 if ( userData ) {
3993 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3994 data = new wxPyUserData(userData);
3995 wxPyEndBlockThreads(blocked);
3996 }
3997 return new wxSizerItem(width, height, proportion, flag, border, data);
3998 }
3999 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4000 wxPyUserData* data = NULL;
4001 if ( userData ) {
4002 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4003 data = new wxPyUserData(userData);
4004 wxPyEndBlockThreads(blocked);
4005 }
4006 return new wxSizerItem(sizer, proportion, flag, border, data);
4007 }
4008
4009 SWIGINTERNINLINE PyObject *
4010 SWIG_From_float (float value)
4011 {
4012 return SWIG_From_double (value);
4013 }
4014
4015 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4016 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4017 if (data) {
4018 Py_INCREF(data->m_obj);
4019 return data->m_obj;
4020 } else {
4021 Py_INCREF(Py_None);
4022 return Py_None;
4023 }
4024 }
4025 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4026 wxPyUserData* data = NULL;
4027 if ( userData ) {
4028 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4029 data = new wxPyUserData(userData);
4030 wxPyEndBlockThreads(blocked);
4031 }
4032 self->SetUserData(data);
4033 }
4034
4035 // Figure out the type of the sizer item
4036
4037 struct wxPySizerItemInfo {
4038 wxPySizerItemInfo()
4039 : window(NULL), sizer(NULL), gotSize(false),
4040 size(wxDefaultSize), gotPos(false), pos(-1)
4041 {}
4042
4043 wxWindow* window;
4044 wxSizer* sizer;
4045 bool gotSize;
4046 wxSize size;
4047 bool gotPos;
4048 int pos;
4049 };
4050
4051 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4052
4053 wxPySizerItemInfo info;
4054 wxSize size;
4055 wxSize* sizePtr = &size;
4056
4057 // Find out what the type of the item is
4058 // try wxWindow
4059 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4060 PyErr_Clear();
4061 info.window = NULL;
4062
4063 // try wxSizer
4064 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4065 PyErr_Clear();
4066 info.sizer = NULL;
4067
4068 // try wxSize or (w,h)
4069 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4070 info.size = *sizePtr;
4071 info.gotSize = true;
4072 }
4073
4074 // or a single int
4075 if (checkIdx && PyInt_Check(item)) {
4076 info.pos = PyInt_AsLong(item);
4077 info.gotPos = true;
4078 }
4079 }
4080 }
4081
4082 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4083 // no expected type, figure out what kind of error message to generate
4084 if ( !checkSize && !checkIdx )
4085 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4086 else if ( checkSize && !checkIdx )
4087 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4088 else if ( !checkSize && checkIdx)
4089 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4090 else
4091 // can this one happen?
4092 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4093 }
4094
4095 return info;
4096 }
4097
4098 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4099 if (!self->GetClientObject())
4100 self->SetClientObject(new wxPyOORClientData(_self));
4101 }
4102 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4103
4104 wxPyUserData* data = NULL;
4105 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4106 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4107 if ( userData && (info.window || info.sizer || info.gotSize) )
4108 data = new wxPyUserData(userData);
4109 if ( info.sizer )
4110 PyObject_SetAttrString(item,"thisown",Py_False);
4111 wxPyEndBlockThreads(blocked);
4112
4113 // Now call the real Add method if a valid item type was found
4114 if ( info.window )
4115 return self->Add(info.window, proportion, flag, border, data);
4116 else if ( info.sizer )
4117 return self->Add(info.sizer, proportion, flag, border, data);
4118 else if (info.gotSize)
4119 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4120 proportion, flag, border, data);
4121 else
4122 return NULL;
4123 }
4124 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4125
4126 wxPyUserData* data = NULL;
4127 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4128 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4129 if ( userData && (info.window || info.sizer || info.gotSize) )
4130 data = new wxPyUserData(userData);
4131 if ( info.sizer )
4132 PyObject_SetAttrString(item,"thisown",Py_False);
4133 wxPyEndBlockThreads(blocked);
4134
4135 // Now call the real Insert method if a valid item type was found
4136 if ( info.window )
4137 return self->Insert(before, info.window, proportion, flag, border, data);
4138 else if ( info.sizer )
4139 return self->Insert(before, info.sizer, proportion, flag, border, data);
4140 else if (info.gotSize)
4141 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4142 proportion, flag, border, data);
4143 else
4144 return NULL;
4145 }
4146 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4147
4148 wxPyUserData* data = NULL;
4149 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4150 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4151 if ( userData && (info.window || info.sizer || info.gotSize) )
4152 data = new wxPyUserData(userData);
4153 if ( info.sizer )
4154 PyObject_SetAttrString(item,"thisown",Py_False);
4155 wxPyEndBlockThreads(blocked);
4156
4157 // Now call the real Prepend method if a valid item type was found
4158 if ( info.window )
4159 return self->Prepend(info.window, proportion, flag, border, data);
4160 else if ( info.sizer )
4161 return self->Prepend(info.sizer, proportion, flag, border, data);
4162 else if (info.gotSize)
4163 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4164 proportion, flag, border, data);
4165 else
4166 return NULL;
4167 }
4168 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4169 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4170 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4171 wxPyEndBlockThreads(blocked);
4172 if ( info.window )
4173 return self->Remove(info.window);
4174 else if ( info.sizer )
4175 return self->Remove(info.sizer);
4176 else if ( info.gotPos )
4177 return self->Remove(info.pos);
4178 else
4179 return false;
4180 }
4181 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4182 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4183 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4184 wxPyEndBlockThreads(blocked);
4185 if ( info.window )
4186 return self->Detach(info.window);
4187 else if ( info.sizer )
4188 return self->Detach(info.sizer);
4189 else if ( info.gotPos )
4190 return self->Detach(info.pos);
4191 else
4192 return false;
4193 }
4194 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4195 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4196 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4197 wxPyEndBlockThreads(blocked);
4198 if ( info.window )
4199 return self->GetItem(info.window);
4200 else if ( info.sizer )
4201 return self->GetItem(info.sizer);
4202 else if ( info.gotPos )
4203 return self->GetItem(info.pos);
4204 else
4205 return NULL;
4206 }
4207 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4209 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4210 wxPyEndBlockThreads(blocked);
4211 if ( info.window )
4212 self->SetItemMinSize(info.window, size);
4213 else if ( info.sizer )
4214 self->SetItemMinSize(info.sizer, size);
4215 else if ( info.gotPos )
4216 self->SetItemMinSize(info.pos, size);
4217 }
4218 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4219 wxSizerItemList& list = self->GetChildren();
4220 return wxPy_ConvertList(&list);
4221 }
4222 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4224 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4225 wxPyEndBlockThreads(blocked);
4226 if ( info.window )
4227 return self->Show(info.window, show, recursive);
4228 else if ( info.sizer )
4229 return self->Show(info.sizer, show, recursive);
4230 else if ( info.gotPos )
4231 return self->Show(info.pos, show);
4232 else
4233 return false;
4234 }
4235 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4236 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4237 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4238 wxPyEndBlockThreads(blocked);
4239 if ( info.window )
4240 return self->IsShown(info.window);
4241 else if ( info.sizer )
4242 return self->IsShown(info.sizer);
4243 else if ( info.gotPos )
4244 return self->IsShown(info.pos);
4245 else
4246 return false;
4247 }
4248
4249 // See pyclasses.h
4250 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4251 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4252 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4253
4254
4255
4256
4257 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4258 {
4259 if (source == Py_None) {
4260 **obj = wxGBPosition(-1,-1);
4261 return true;
4262 }
4263 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4264 }
4265
4266 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4267 {
4268 if (source == Py_None) {
4269 **obj = wxGBSpan(-1,-1);
4270 return true;
4271 }
4272 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4273 }
4274
4275
4276 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4277 wxGBPosition temp, *obj = &temp;
4278 if ( other == Py_None ) return false;
4279 if ( ! wxGBPosition_helper(other, &obj) ) {
4280 PyErr_Clear();
4281 return false;
4282 }
4283 return self->operator==(*obj);
4284 }
4285 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4286 wxGBPosition temp, *obj = &temp;
4287 if ( other == Py_None ) return true;
4288 if ( ! wxGBPosition_helper(other, &obj)) {
4289 PyErr_Clear();
4290 return true;
4291 }
4292 return self->operator!=(*obj);
4293 }
4294 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4295 self->SetRow(row);
4296 self->SetCol(col);
4297 }
4298 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4299 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4300 PyObject* tup = PyTuple_New(2);
4301 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4302 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4303 wxPyEndBlockThreads(blocked);
4304 return tup;
4305 }
4306 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4307 wxGBSpan temp, *obj = &temp;
4308 if ( other == Py_None ) return false;
4309 if ( ! wxGBSpan_helper(other, &obj) ) {
4310 PyErr_Clear();
4311 return false;
4312 }
4313 return self->operator==(*obj);
4314 }
4315 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4316 wxGBSpan temp, *obj = &temp;
4317 if ( other == Py_None ) return true;
4318 if ( ! wxGBSpan_helper(other, &obj)) {
4319 PyErr_Clear();
4320 return true;
4321 }
4322 return self->operator!=(*obj);
4323 }
4324 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4325 self->SetRowspan(rowspan);
4326 self->SetColspan(colspan);
4327 }
4328 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4329 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4330 PyObject* tup = PyTuple_New(2);
4331 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4332 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4333 wxPyEndBlockThreads(blocked);
4334 return tup;
4335 }
4336 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4337 wxPyUserData* data = NULL;
4338 if ( userData ) {
4339 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4340 data = new wxPyUserData(userData);
4341 wxPyEndBlockThreads(blocked);
4342 }
4343 return new wxGBSizerItem(window, pos, span, flag, border, data);
4344 }
4345 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4346 wxPyUserData* data = NULL;
4347 if ( userData ) {
4348 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4349 data = new wxPyUserData(userData);
4350 wxPyEndBlockThreads(blocked);
4351 }
4352 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4353 }
4354 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4355 wxPyUserData* data = NULL;
4356 if ( userData ) {
4357 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4358 data = new wxPyUserData(userData);
4359 wxPyEndBlockThreads(blocked);
4360 }
4361 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4362 }
4363 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4364 int row, col;
4365 self->GetEndPos(row, col);
4366 return wxGBPosition(row, col);
4367 }
4368 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4369
4370 wxPyUserData* data = NULL;
4371 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4372 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4373 if ( userData && (info.window || info.sizer || info.gotSize) )
4374 data = new wxPyUserData(userData);
4375 if ( info.sizer )
4376 PyObject_SetAttrString(item,"thisown",Py_False);
4377 wxPyEndBlockThreads(blocked);
4378
4379 // Now call the real Add method if a valid item type was found
4380 if ( info.window )
4381 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4382 else if ( info.sizer )
4383 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4384 else if (info.gotSize)
4385 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4386 pos, span, flag, border, data);
4387 return NULL;
4388 }
4389
4390
4391 #ifdef __cplusplus
4392 extern "C" {
4393 #endif
4394 SWIGINTERN int EmptyString_set(PyObject *) {
4395 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4396 return 1;
4397 }
4398
4399
4400 SWIGINTERN PyObject *EmptyString_get(void) {
4401 PyObject *pyobj = 0;
4402
4403 {
4404 #if wxUSE_UNICODE
4405 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4406 #else
4407 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4408 #endif
4409 }
4410 return pyobj;
4411 }
4412
4413
4414 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4415 PyObject *resultobj = 0;
4416 wxObject *arg1 = (wxObject *) 0 ;
4417 wxString result;
4418 void *argp1 = 0 ;
4419 int res1 = 0 ;
4420 PyObject *swig_obj[1] ;
4421
4422 if (!args) SWIG_fail;
4423 swig_obj[0] = args;
4424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4425 if (!SWIG_IsOK(res1)) {
4426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4427 }
4428 arg1 = reinterpret_cast< wxObject * >(argp1);
4429 {
4430 PyThreadState* __tstate = wxPyBeginAllowThreads();
4431 result = wxObject_GetClassName(arg1);
4432 wxPyEndAllowThreads(__tstate);
4433 if (PyErr_Occurred()) SWIG_fail;
4434 }
4435 {
4436 #if wxUSE_UNICODE
4437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4438 #else
4439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4440 #endif
4441 }
4442 return resultobj;
4443 fail:
4444 return NULL;
4445 }
4446
4447
4448 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4449 PyObject *resultobj = 0;
4450 wxObject *arg1 = (wxObject *) 0 ;
4451 void *argp1 = 0 ;
4452 int res1 = 0 ;
4453 PyObject *swig_obj[1] ;
4454
4455 if (!args) SWIG_fail;
4456 swig_obj[0] = args;
4457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4458 if (!SWIG_IsOK(res1)) {
4459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4460 }
4461 arg1 = reinterpret_cast< wxObject * >(argp1);
4462 {
4463 PyThreadState* __tstate = wxPyBeginAllowThreads();
4464 wxObject_Destroy(arg1);
4465 wxPyEndAllowThreads(__tstate);
4466 if (PyErr_Occurred()) SWIG_fail;
4467 }
4468 resultobj = SWIG_Py_Void();
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4476 PyObject *obj;
4477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4478 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4479 return SWIG_Py_Void();
4480 }
4481
4482 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4483 PyObject *resultobj = 0;
4484 wxSize *arg1 = (wxSize *) 0 ;
4485 int arg2 ;
4486 void *argp1 = 0 ;
4487 int res1 = 0 ;
4488 int val2 ;
4489 int ecode2 = 0 ;
4490 PyObject *swig_obj[2] ;
4491
4492 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4494 if (!SWIG_IsOK(res1)) {
4495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4496 }
4497 arg1 = reinterpret_cast< wxSize * >(argp1);
4498 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4499 if (!SWIG_IsOK(ecode2)) {
4500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4501 }
4502 arg2 = static_cast< int >(val2);
4503 if (arg1) (arg1)->x = arg2;
4504
4505 resultobj = SWIG_Py_Void();
4506 return resultobj;
4507 fail:
4508 return NULL;
4509 }
4510
4511
4512 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4513 PyObject *resultobj = 0;
4514 wxSize *arg1 = (wxSize *) 0 ;
4515 int result;
4516 void *argp1 = 0 ;
4517 int res1 = 0 ;
4518 PyObject *swig_obj[1] ;
4519
4520 if (!args) SWIG_fail;
4521 swig_obj[0] = args;
4522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4523 if (!SWIG_IsOK(res1)) {
4524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4525 }
4526 arg1 = reinterpret_cast< wxSize * >(argp1);
4527 result = (int) ((arg1)->x);
4528 resultobj = SWIG_From_int(static_cast< int >(result));
4529 return resultobj;
4530 fail:
4531 return NULL;
4532 }
4533
4534
4535 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4536 PyObject *resultobj = 0;
4537 wxSize *arg1 = (wxSize *) 0 ;
4538 int arg2 ;
4539 void *argp1 = 0 ;
4540 int res1 = 0 ;
4541 int val2 ;
4542 int ecode2 = 0 ;
4543 PyObject *swig_obj[2] ;
4544
4545 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4547 if (!SWIG_IsOK(res1)) {
4548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4549 }
4550 arg1 = reinterpret_cast< wxSize * >(argp1);
4551 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4552 if (!SWIG_IsOK(ecode2)) {
4553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4554 }
4555 arg2 = static_cast< int >(val2);
4556 if (arg1) (arg1)->y = arg2;
4557
4558 resultobj = SWIG_Py_Void();
4559 return resultobj;
4560 fail:
4561 return NULL;
4562 }
4563
4564
4565 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4566 PyObject *resultobj = 0;
4567 wxSize *arg1 = (wxSize *) 0 ;
4568 int result;
4569 void *argp1 = 0 ;
4570 int res1 = 0 ;
4571 PyObject *swig_obj[1] ;
4572
4573 if (!args) SWIG_fail;
4574 swig_obj[0] = args;
4575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4576 if (!SWIG_IsOK(res1)) {
4577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4578 }
4579 arg1 = reinterpret_cast< wxSize * >(argp1);
4580 result = (int) ((arg1)->y);
4581 resultobj = SWIG_From_int(static_cast< int >(result));
4582 return resultobj;
4583 fail:
4584 return NULL;
4585 }
4586
4587
4588 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4589 PyObject *resultobj = 0;
4590 int arg1 = (int) 0 ;
4591 int arg2 = (int) 0 ;
4592 wxSize *result = 0 ;
4593 int val1 ;
4594 int ecode1 = 0 ;
4595 int val2 ;
4596 int ecode2 = 0 ;
4597 PyObject * obj0 = 0 ;
4598 PyObject * obj1 = 0 ;
4599 char * kwnames[] = {
4600 (char *) "w",(char *) "h", NULL
4601 };
4602
4603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4604 if (obj0) {
4605 ecode1 = SWIG_AsVal_int(obj0, &val1);
4606 if (!SWIG_IsOK(ecode1)) {
4607 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4608 }
4609 arg1 = static_cast< int >(val1);
4610 }
4611 if (obj1) {
4612 ecode2 = SWIG_AsVal_int(obj1, &val2);
4613 if (!SWIG_IsOK(ecode2)) {
4614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4615 }
4616 arg2 = static_cast< int >(val2);
4617 }
4618 {
4619 PyThreadState* __tstate = wxPyBeginAllowThreads();
4620 result = (wxSize *)new wxSize(arg1,arg2);
4621 wxPyEndAllowThreads(__tstate);
4622 if (PyErr_Occurred()) SWIG_fail;
4623 }
4624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4625 return resultobj;
4626 fail:
4627 return NULL;
4628 }
4629
4630
4631 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4632 PyObject *resultobj = 0;
4633 wxSize *arg1 = (wxSize *) 0 ;
4634 void *argp1 = 0 ;
4635 int res1 = 0 ;
4636 PyObject *swig_obj[1] ;
4637
4638 if (!args) SWIG_fail;
4639 swig_obj[0] = args;
4640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4641 if (!SWIG_IsOK(res1)) {
4642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4643 }
4644 arg1 = reinterpret_cast< wxSize * >(argp1);
4645 {
4646 PyThreadState* __tstate = wxPyBeginAllowThreads();
4647 delete arg1;
4648
4649 wxPyEndAllowThreads(__tstate);
4650 if (PyErr_Occurred()) SWIG_fail;
4651 }
4652 resultobj = SWIG_Py_Void();
4653 return resultobj;
4654 fail:
4655 return NULL;
4656 }
4657
4658
4659 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4660 PyObject *resultobj = 0;
4661 wxSize *arg1 = (wxSize *) 0 ;
4662 PyObject *arg2 = (PyObject *) 0 ;
4663 bool result;
4664 void *argp1 = 0 ;
4665 int res1 = 0 ;
4666 PyObject * obj0 = 0 ;
4667 PyObject * obj1 = 0 ;
4668 char * kwnames[] = {
4669 (char *) "self",(char *) "other", NULL
4670 };
4671
4672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4674 if (!SWIG_IsOK(res1)) {
4675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4676 }
4677 arg1 = reinterpret_cast< wxSize * >(argp1);
4678 arg2 = obj1;
4679 {
4680 result = (bool)wxSize___eq__(arg1,arg2);
4681 if (PyErr_Occurred()) SWIG_fail;
4682 }
4683 {
4684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4685 }
4686 return resultobj;
4687 fail:
4688 return NULL;
4689 }
4690
4691
4692 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4693 PyObject *resultobj = 0;
4694 wxSize *arg1 = (wxSize *) 0 ;
4695 PyObject *arg2 = (PyObject *) 0 ;
4696 bool result;
4697 void *argp1 = 0 ;
4698 int res1 = 0 ;
4699 PyObject * obj0 = 0 ;
4700 PyObject * obj1 = 0 ;
4701 char * kwnames[] = {
4702 (char *) "self",(char *) "other", NULL
4703 };
4704
4705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4707 if (!SWIG_IsOK(res1)) {
4708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4709 }
4710 arg1 = reinterpret_cast< wxSize * >(argp1);
4711 arg2 = obj1;
4712 {
4713 result = (bool)wxSize___ne__(arg1,arg2);
4714 if (PyErr_Occurred()) SWIG_fail;
4715 }
4716 {
4717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4718 }
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4726 PyObject *resultobj = 0;
4727 wxSize *arg1 = (wxSize *) 0 ;
4728 wxSize *arg2 = 0 ;
4729 wxSize result;
4730 void *argp1 = 0 ;
4731 int res1 = 0 ;
4732 wxSize temp2 ;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 char * kwnames[] = {
4736 (char *) "self",(char *) "sz", NULL
4737 };
4738
4739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4741 if (!SWIG_IsOK(res1)) {
4742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4743 }
4744 arg1 = reinterpret_cast< wxSize * >(argp1);
4745 {
4746 arg2 = &temp2;
4747 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4748 }
4749 {
4750 PyThreadState* __tstate = wxPyBeginAllowThreads();
4751 result = (arg1)->operator +((wxSize const &)*arg2);
4752 wxPyEndAllowThreads(__tstate);
4753 if (PyErr_Occurred()) SWIG_fail;
4754 }
4755 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4756 return resultobj;
4757 fail:
4758 return NULL;
4759 }
4760
4761
4762 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4763 PyObject *resultobj = 0;
4764 wxSize *arg1 = (wxSize *) 0 ;
4765 wxSize *arg2 = 0 ;
4766 wxSize result;
4767 void *argp1 = 0 ;
4768 int res1 = 0 ;
4769 wxSize temp2 ;
4770 PyObject * obj0 = 0 ;
4771 PyObject * obj1 = 0 ;
4772 char * kwnames[] = {
4773 (char *) "self",(char *) "sz", NULL
4774 };
4775
4776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4778 if (!SWIG_IsOK(res1)) {
4779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4780 }
4781 arg1 = reinterpret_cast< wxSize * >(argp1);
4782 {
4783 arg2 = &temp2;
4784 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4785 }
4786 {
4787 PyThreadState* __tstate = wxPyBeginAllowThreads();
4788 result = (arg1)->operator -((wxSize const &)*arg2);
4789 wxPyEndAllowThreads(__tstate);
4790 if (PyErr_Occurred()) SWIG_fail;
4791 }
4792 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4793 return resultobj;
4794 fail:
4795 return NULL;
4796 }
4797
4798
4799 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4800 PyObject *resultobj = 0;
4801 wxSize *arg1 = (wxSize *) 0 ;
4802 wxSize *arg2 = 0 ;
4803 void *argp1 = 0 ;
4804 int res1 = 0 ;
4805 wxSize temp2 ;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 char * kwnames[] = {
4809 (char *) "self",(char *) "sz", NULL
4810 };
4811
4812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4814 if (!SWIG_IsOK(res1)) {
4815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4816 }
4817 arg1 = reinterpret_cast< wxSize * >(argp1);
4818 {
4819 arg2 = &temp2;
4820 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4821 }
4822 {
4823 PyThreadState* __tstate = wxPyBeginAllowThreads();
4824 (arg1)->IncTo((wxSize const &)*arg2);
4825 wxPyEndAllowThreads(__tstate);
4826 if (PyErr_Occurred()) SWIG_fail;
4827 }
4828 resultobj = SWIG_Py_Void();
4829 return resultobj;
4830 fail:
4831 return NULL;
4832 }
4833
4834
4835 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4836 PyObject *resultobj = 0;
4837 wxSize *arg1 = (wxSize *) 0 ;
4838 wxSize *arg2 = 0 ;
4839 void *argp1 = 0 ;
4840 int res1 = 0 ;
4841 wxSize temp2 ;
4842 PyObject * obj0 = 0 ;
4843 PyObject * obj1 = 0 ;
4844 char * kwnames[] = {
4845 (char *) "self",(char *) "sz", NULL
4846 };
4847
4848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4850 if (!SWIG_IsOK(res1)) {
4851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4852 }
4853 arg1 = reinterpret_cast< wxSize * >(argp1);
4854 {
4855 arg2 = &temp2;
4856 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4857 }
4858 {
4859 PyThreadState* __tstate = wxPyBeginAllowThreads();
4860 (arg1)->DecTo((wxSize const &)*arg2);
4861 wxPyEndAllowThreads(__tstate);
4862 if (PyErr_Occurred()) SWIG_fail;
4863 }
4864 resultobj = SWIG_Py_Void();
4865 return resultobj;
4866 fail:
4867 return NULL;
4868 }
4869
4870
4871 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4872 PyObject *resultobj = 0;
4873 wxSize *arg1 = (wxSize *) 0 ;
4874 int arg2 ;
4875 int arg3 ;
4876 void *argp1 = 0 ;
4877 int res1 = 0 ;
4878 int val2 ;
4879 int ecode2 = 0 ;
4880 int val3 ;
4881 int ecode3 = 0 ;
4882 PyObject * obj0 = 0 ;
4883 PyObject * obj1 = 0 ;
4884 PyObject * obj2 = 0 ;
4885 char * kwnames[] = {
4886 (char *) "self",(char *) "dx",(char *) "dy", NULL
4887 };
4888
4889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4891 if (!SWIG_IsOK(res1)) {
4892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4893 }
4894 arg1 = reinterpret_cast< wxSize * >(argp1);
4895 ecode2 = SWIG_AsVal_int(obj1, &val2);
4896 if (!SWIG_IsOK(ecode2)) {
4897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4898 }
4899 arg2 = static_cast< int >(val2);
4900 ecode3 = SWIG_AsVal_int(obj2, &val3);
4901 if (!SWIG_IsOK(ecode3)) {
4902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4903 }
4904 arg3 = static_cast< int >(val3);
4905 {
4906 PyThreadState* __tstate = wxPyBeginAllowThreads();
4907 (arg1)->IncBy(arg2,arg3);
4908 wxPyEndAllowThreads(__tstate);
4909 if (PyErr_Occurred()) SWIG_fail;
4910 }
4911 resultobj = SWIG_Py_Void();
4912 return resultobj;
4913 fail:
4914 return NULL;
4915 }
4916
4917
4918 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4919 PyObject *resultobj = 0;
4920 wxSize *arg1 = (wxSize *) 0 ;
4921 int arg2 ;
4922 int arg3 ;
4923 void *argp1 = 0 ;
4924 int res1 = 0 ;
4925 int val2 ;
4926 int ecode2 = 0 ;
4927 int val3 ;
4928 int ecode3 = 0 ;
4929 PyObject * obj0 = 0 ;
4930 PyObject * obj1 = 0 ;
4931 PyObject * obj2 = 0 ;
4932 char * kwnames[] = {
4933 (char *) "self",(char *) "dx",(char *) "dy", NULL
4934 };
4935
4936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4938 if (!SWIG_IsOK(res1)) {
4939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4940 }
4941 arg1 = reinterpret_cast< wxSize * >(argp1);
4942 ecode2 = SWIG_AsVal_int(obj1, &val2);
4943 if (!SWIG_IsOK(ecode2)) {
4944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
4945 }
4946 arg2 = static_cast< int >(val2);
4947 ecode3 = SWIG_AsVal_int(obj2, &val3);
4948 if (!SWIG_IsOK(ecode3)) {
4949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
4950 }
4951 arg3 = static_cast< int >(val3);
4952 {
4953 PyThreadState* __tstate = wxPyBeginAllowThreads();
4954 (arg1)->DecBy(arg2,arg3);
4955 wxPyEndAllowThreads(__tstate);
4956 if (PyErr_Occurred()) SWIG_fail;
4957 }
4958 resultobj = SWIG_Py_Void();
4959 return resultobj;
4960 fail:
4961 return NULL;
4962 }
4963
4964
4965 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4966 PyObject *resultobj = 0;
4967 wxSize *arg1 = (wxSize *) 0 ;
4968 float arg2 ;
4969 float arg3 ;
4970 void *argp1 = 0 ;
4971 int res1 = 0 ;
4972 float val2 ;
4973 int ecode2 = 0 ;
4974 float val3 ;
4975 int ecode3 = 0 ;
4976 PyObject * obj0 = 0 ;
4977 PyObject * obj1 = 0 ;
4978 PyObject * obj2 = 0 ;
4979 char * kwnames[] = {
4980 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4981 };
4982
4983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4985 if (!SWIG_IsOK(res1)) {
4986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4987 }
4988 arg1 = reinterpret_cast< wxSize * >(argp1);
4989 ecode2 = SWIG_AsVal_float(obj1, &val2);
4990 if (!SWIG_IsOK(ecode2)) {
4991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4992 }
4993 arg2 = static_cast< float >(val2);
4994 ecode3 = SWIG_AsVal_float(obj2, &val3);
4995 if (!SWIG_IsOK(ecode3)) {
4996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4997 }
4998 arg3 = static_cast< float >(val3);
4999 {
5000 PyThreadState* __tstate = wxPyBeginAllowThreads();
5001 (arg1)->Scale(arg2,arg3);
5002 wxPyEndAllowThreads(__tstate);
5003 if (PyErr_Occurred()) SWIG_fail;
5004 }
5005 resultobj = SWIG_Py_Void();
5006 return resultobj;
5007 fail:
5008 return NULL;
5009 }
5010
5011
5012 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5013 PyObject *resultobj = 0;
5014 wxSize *arg1 = (wxSize *) 0 ;
5015 int arg2 ;
5016 int arg3 ;
5017 void *argp1 = 0 ;
5018 int res1 = 0 ;
5019 int val2 ;
5020 int ecode2 = 0 ;
5021 int val3 ;
5022 int ecode3 = 0 ;
5023 PyObject * obj0 = 0 ;
5024 PyObject * obj1 = 0 ;
5025 PyObject * obj2 = 0 ;
5026 char * kwnames[] = {
5027 (char *) "self",(char *) "w",(char *) "h", NULL
5028 };
5029
5030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5032 if (!SWIG_IsOK(res1)) {
5033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5034 }
5035 arg1 = reinterpret_cast< wxSize * >(argp1);
5036 ecode2 = SWIG_AsVal_int(obj1, &val2);
5037 if (!SWIG_IsOK(ecode2)) {
5038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5039 }
5040 arg2 = static_cast< int >(val2);
5041 ecode3 = SWIG_AsVal_int(obj2, &val3);
5042 if (!SWIG_IsOK(ecode3)) {
5043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5044 }
5045 arg3 = static_cast< int >(val3);
5046 {
5047 PyThreadState* __tstate = wxPyBeginAllowThreads();
5048 (arg1)->Set(arg2,arg3);
5049 wxPyEndAllowThreads(__tstate);
5050 if (PyErr_Occurred()) SWIG_fail;
5051 }
5052 resultobj = SWIG_Py_Void();
5053 return resultobj;
5054 fail:
5055 return NULL;
5056 }
5057
5058
5059 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5060 PyObject *resultobj = 0;
5061 wxSize *arg1 = (wxSize *) 0 ;
5062 int arg2 ;
5063 void *argp1 = 0 ;
5064 int res1 = 0 ;
5065 int val2 ;
5066 int ecode2 = 0 ;
5067 PyObject * obj0 = 0 ;
5068 PyObject * obj1 = 0 ;
5069 char * kwnames[] = {
5070 (char *) "self",(char *) "w", NULL
5071 };
5072
5073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5075 if (!SWIG_IsOK(res1)) {
5076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5077 }
5078 arg1 = reinterpret_cast< wxSize * >(argp1);
5079 ecode2 = SWIG_AsVal_int(obj1, &val2);
5080 if (!SWIG_IsOK(ecode2)) {
5081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5082 }
5083 arg2 = static_cast< int >(val2);
5084 {
5085 PyThreadState* __tstate = wxPyBeginAllowThreads();
5086 (arg1)->SetWidth(arg2);
5087 wxPyEndAllowThreads(__tstate);
5088 if (PyErr_Occurred()) SWIG_fail;
5089 }
5090 resultobj = SWIG_Py_Void();
5091 return resultobj;
5092 fail:
5093 return NULL;
5094 }
5095
5096
5097 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5098 PyObject *resultobj = 0;
5099 wxSize *arg1 = (wxSize *) 0 ;
5100 int arg2 ;
5101 void *argp1 = 0 ;
5102 int res1 = 0 ;
5103 int val2 ;
5104 int ecode2 = 0 ;
5105 PyObject * obj0 = 0 ;
5106 PyObject * obj1 = 0 ;
5107 char * kwnames[] = {
5108 (char *) "self",(char *) "h", NULL
5109 };
5110
5111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5113 if (!SWIG_IsOK(res1)) {
5114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5115 }
5116 arg1 = reinterpret_cast< wxSize * >(argp1);
5117 ecode2 = SWIG_AsVal_int(obj1, &val2);
5118 if (!SWIG_IsOK(ecode2)) {
5119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5120 }
5121 arg2 = static_cast< int >(val2);
5122 {
5123 PyThreadState* __tstate = wxPyBeginAllowThreads();
5124 (arg1)->SetHeight(arg2);
5125 wxPyEndAllowThreads(__tstate);
5126 if (PyErr_Occurred()) SWIG_fail;
5127 }
5128 resultobj = SWIG_Py_Void();
5129 return resultobj;
5130 fail:
5131 return NULL;
5132 }
5133
5134
5135 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5136 PyObject *resultobj = 0;
5137 wxSize *arg1 = (wxSize *) 0 ;
5138 int result;
5139 void *argp1 = 0 ;
5140 int res1 = 0 ;
5141 PyObject *swig_obj[1] ;
5142
5143 if (!args) SWIG_fail;
5144 swig_obj[0] = args;
5145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5146 if (!SWIG_IsOK(res1)) {
5147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5148 }
5149 arg1 = reinterpret_cast< wxSize * >(argp1);
5150 {
5151 PyThreadState* __tstate = wxPyBeginAllowThreads();
5152 result = (int)((wxSize const *)arg1)->GetWidth();
5153 wxPyEndAllowThreads(__tstate);
5154 if (PyErr_Occurred()) SWIG_fail;
5155 }
5156 resultobj = SWIG_From_int(static_cast< int >(result));
5157 return resultobj;
5158 fail:
5159 return NULL;
5160 }
5161
5162
5163 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5164 PyObject *resultobj = 0;
5165 wxSize *arg1 = (wxSize *) 0 ;
5166 int result;
5167 void *argp1 = 0 ;
5168 int res1 = 0 ;
5169 PyObject *swig_obj[1] ;
5170
5171 if (!args) SWIG_fail;
5172 swig_obj[0] = args;
5173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5174 if (!SWIG_IsOK(res1)) {
5175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5176 }
5177 arg1 = reinterpret_cast< wxSize * >(argp1);
5178 {
5179 PyThreadState* __tstate = wxPyBeginAllowThreads();
5180 result = (int)((wxSize const *)arg1)->GetHeight();
5181 wxPyEndAllowThreads(__tstate);
5182 if (PyErr_Occurred()) SWIG_fail;
5183 }
5184 resultobj = SWIG_From_int(static_cast< int >(result));
5185 return resultobj;
5186 fail:
5187 return NULL;
5188 }
5189
5190
5191 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5192 PyObject *resultobj = 0;
5193 wxSize *arg1 = (wxSize *) 0 ;
5194 bool result;
5195 void *argp1 = 0 ;
5196 int res1 = 0 ;
5197 PyObject *swig_obj[1] ;
5198
5199 if (!args) SWIG_fail;
5200 swig_obj[0] = args;
5201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5202 if (!SWIG_IsOK(res1)) {
5203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5204 }
5205 arg1 = reinterpret_cast< wxSize * >(argp1);
5206 {
5207 PyThreadState* __tstate = wxPyBeginAllowThreads();
5208 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5209 wxPyEndAllowThreads(__tstate);
5210 if (PyErr_Occurred()) SWIG_fail;
5211 }
5212 {
5213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5214 }
5215 return resultobj;
5216 fail:
5217 return NULL;
5218 }
5219
5220
5221 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5222 PyObject *resultobj = 0;
5223 wxSize *arg1 = (wxSize *) 0 ;
5224 wxSize *arg2 = 0 ;
5225 void *argp1 = 0 ;
5226 int res1 = 0 ;
5227 wxSize temp2 ;
5228 PyObject * obj0 = 0 ;
5229 PyObject * obj1 = 0 ;
5230 char * kwnames[] = {
5231 (char *) "self",(char *) "size", NULL
5232 };
5233
5234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5236 if (!SWIG_IsOK(res1)) {
5237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5238 }
5239 arg1 = reinterpret_cast< wxSize * >(argp1);
5240 {
5241 arg2 = &temp2;
5242 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5243 }
5244 {
5245 PyThreadState* __tstate = wxPyBeginAllowThreads();
5246 (arg1)->SetDefaults((wxSize const &)*arg2);
5247 wxPyEndAllowThreads(__tstate);
5248 if (PyErr_Occurred()) SWIG_fail;
5249 }
5250 resultobj = SWIG_Py_Void();
5251 return resultobj;
5252 fail:
5253 return NULL;
5254 }
5255
5256
5257 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5258 PyObject *resultobj = 0;
5259 wxSize *arg1 = (wxSize *) 0 ;
5260 PyObject *result = 0 ;
5261 void *argp1 = 0 ;
5262 int res1 = 0 ;
5263 PyObject *swig_obj[1] ;
5264
5265 if (!args) SWIG_fail;
5266 swig_obj[0] = args;
5267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5268 if (!SWIG_IsOK(res1)) {
5269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5270 }
5271 arg1 = reinterpret_cast< wxSize * >(argp1);
5272 {
5273 PyThreadState* __tstate = wxPyBeginAllowThreads();
5274 result = (PyObject *)wxSize_Get(arg1);
5275 wxPyEndAllowThreads(__tstate);
5276 if (PyErr_Occurred()) SWIG_fail;
5277 }
5278 resultobj = result;
5279 return resultobj;
5280 fail:
5281 return NULL;
5282 }
5283
5284
5285 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5286 PyObject *obj;
5287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5288 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5289 return SWIG_Py_Void();
5290 }
5291
5292 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5293 return SWIG_Python_InitShadowInstance(args);
5294 }
5295
5296 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5297 PyObject *resultobj = 0;
5298 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5299 double arg2 ;
5300 void *argp1 = 0 ;
5301 int res1 = 0 ;
5302 double val2 ;
5303 int ecode2 = 0 ;
5304 PyObject *swig_obj[2] ;
5305
5306 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5308 if (!SWIG_IsOK(res1)) {
5309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5310 }
5311 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5312 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5313 if (!SWIG_IsOK(ecode2)) {
5314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5315 }
5316 arg2 = static_cast< double >(val2);
5317 if (arg1) (arg1)->x = arg2;
5318
5319 resultobj = SWIG_Py_Void();
5320 return resultobj;
5321 fail:
5322 return NULL;
5323 }
5324
5325
5326 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5327 PyObject *resultobj = 0;
5328 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5329 double result;
5330 void *argp1 = 0 ;
5331 int res1 = 0 ;
5332 PyObject *swig_obj[1] ;
5333
5334 if (!args) SWIG_fail;
5335 swig_obj[0] = args;
5336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5337 if (!SWIG_IsOK(res1)) {
5338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5339 }
5340 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5341 result = (double) ((arg1)->x);
5342 resultobj = SWIG_From_double(static_cast< double >(result));
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5350 PyObject *resultobj = 0;
5351 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5352 double arg2 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 double val2 ;
5356 int ecode2 = 0 ;
5357 PyObject *swig_obj[2] ;
5358
5359 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5361 if (!SWIG_IsOK(res1)) {
5362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5363 }
5364 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5365 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5366 if (!SWIG_IsOK(ecode2)) {
5367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5368 }
5369 arg2 = static_cast< double >(val2);
5370 if (arg1) (arg1)->y = arg2;
5371
5372 resultobj = SWIG_Py_Void();
5373 return resultobj;
5374 fail:
5375 return NULL;
5376 }
5377
5378
5379 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5380 PyObject *resultobj = 0;
5381 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5382 double result;
5383 void *argp1 = 0 ;
5384 int res1 = 0 ;
5385 PyObject *swig_obj[1] ;
5386
5387 if (!args) SWIG_fail;
5388 swig_obj[0] = args;
5389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5390 if (!SWIG_IsOK(res1)) {
5391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5392 }
5393 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5394 result = (double) ((arg1)->y);
5395 resultobj = SWIG_From_double(static_cast< double >(result));
5396 return resultobj;
5397 fail:
5398 return NULL;
5399 }
5400
5401
5402 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5403 PyObject *resultobj = 0;
5404 double arg1 = (double) 0.0 ;
5405 double arg2 = (double) 0.0 ;
5406 wxRealPoint *result = 0 ;
5407 double val1 ;
5408 int ecode1 = 0 ;
5409 double val2 ;
5410 int ecode2 = 0 ;
5411 PyObject * obj0 = 0 ;
5412 PyObject * obj1 = 0 ;
5413 char * kwnames[] = {
5414 (char *) "x",(char *) "y", NULL
5415 };
5416
5417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5418 if (obj0) {
5419 ecode1 = SWIG_AsVal_double(obj0, &val1);
5420 if (!SWIG_IsOK(ecode1)) {
5421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5422 }
5423 arg1 = static_cast< double >(val1);
5424 }
5425 if (obj1) {
5426 ecode2 = SWIG_AsVal_double(obj1, &val2);
5427 if (!SWIG_IsOK(ecode2)) {
5428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5429 }
5430 arg2 = static_cast< double >(val2);
5431 }
5432 {
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5435 wxPyEndAllowThreads(__tstate);
5436 if (PyErr_Occurred()) SWIG_fail;
5437 }
5438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5439 return resultobj;
5440 fail:
5441 return NULL;
5442 }
5443
5444
5445 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5446 PyObject *resultobj = 0;
5447 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5448 void *argp1 = 0 ;
5449 int res1 = 0 ;
5450 PyObject *swig_obj[1] ;
5451
5452 if (!args) SWIG_fail;
5453 swig_obj[0] = args;
5454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5455 if (!SWIG_IsOK(res1)) {
5456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5457 }
5458 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5459 {
5460 PyThreadState* __tstate = wxPyBeginAllowThreads();
5461 delete arg1;
5462
5463 wxPyEndAllowThreads(__tstate);
5464 if (PyErr_Occurred()) SWIG_fail;
5465 }
5466 resultobj = SWIG_Py_Void();
5467 return resultobj;
5468 fail:
5469 return NULL;
5470 }
5471
5472
5473 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5474 PyObject *resultobj = 0;
5475 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5476 PyObject *arg2 = (PyObject *) 0 ;
5477 bool result;
5478 void *argp1 = 0 ;
5479 int res1 = 0 ;
5480 PyObject * obj0 = 0 ;
5481 PyObject * obj1 = 0 ;
5482 char * kwnames[] = {
5483 (char *) "self",(char *) "other", NULL
5484 };
5485
5486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5488 if (!SWIG_IsOK(res1)) {
5489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5490 }
5491 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5492 arg2 = obj1;
5493 {
5494 result = (bool)wxRealPoint___eq__(arg1,arg2);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 {
5498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5499 }
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj = 0;
5508 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5509 PyObject *arg2 = (PyObject *) 0 ;
5510 bool result;
5511 void *argp1 = 0 ;
5512 int res1 = 0 ;
5513 PyObject * obj0 = 0 ;
5514 PyObject * obj1 = 0 ;
5515 char * kwnames[] = {
5516 (char *) "self",(char *) "other", NULL
5517 };
5518
5519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5521 if (!SWIG_IsOK(res1)) {
5522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5523 }
5524 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5525 arg2 = obj1;
5526 {
5527 result = (bool)wxRealPoint___ne__(arg1,arg2);
5528 if (PyErr_Occurred()) SWIG_fail;
5529 }
5530 {
5531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5532 }
5533 return resultobj;
5534 fail:
5535 return NULL;
5536 }
5537
5538
5539 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5540 PyObject *resultobj = 0;
5541 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5542 wxRealPoint *arg2 = 0 ;
5543 wxRealPoint result;
5544 void *argp1 = 0 ;
5545 int res1 = 0 ;
5546 wxRealPoint temp2 ;
5547 PyObject * obj0 = 0 ;
5548 PyObject * obj1 = 0 ;
5549 char * kwnames[] = {
5550 (char *) "self",(char *) "pt", NULL
5551 };
5552
5553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5555 if (!SWIG_IsOK(res1)) {
5556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5557 }
5558 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5559 {
5560 arg2 = &temp2;
5561 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5562 }
5563 {
5564 PyThreadState* __tstate = wxPyBeginAllowThreads();
5565 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5566 wxPyEndAllowThreads(__tstate);
5567 if (PyErr_Occurred()) SWIG_fail;
5568 }
5569 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5570 return resultobj;
5571 fail:
5572 return NULL;
5573 }
5574
5575
5576 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5577 PyObject *resultobj = 0;
5578 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5579 wxRealPoint *arg2 = 0 ;
5580 wxRealPoint result;
5581 void *argp1 = 0 ;
5582 int res1 = 0 ;
5583 wxRealPoint temp2 ;
5584 PyObject * obj0 = 0 ;
5585 PyObject * obj1 = 0 ;
5586 char * kwnames[] = {
5587 (char *) "self",(char *) "pt", NULL
5588 };
5589
5590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5592 if (!SWIG_IsOK(res1)) {
5593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5594 }
5595 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5596 {
5597 arg2 = &temp2;
5598 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5599 }
5600 {
5601 PyThreadState* __tstate = wxPyBeginAllowThreads();
5602 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5603 wxPyEndAllowThreads(__tstate);
5604 if (PyErr_Occurred()) SWIG_fail;
5605 }
5606 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5607 return resultobj;
5608 fail:
5609 return NULL;
5610 }
5611
5612
5613 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5614 PyObject *resultobj = 0;
5615 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5616 double arg2 ;
5617 double arg3 ;
5618 void *argp1 = 0 ;
5619 int res1 = 0 ;
5620 double val2 ;
5621 int ecode2 = 0 ;
5622 double val3 ;
5623 int ecode3 = 0 ;
5624 PyObject * obj0 = 0 ;
5625 PyObject * obj1 = 0 ;
5626 PyObject * obj2 = 0 ;
5627 char * kwnames[] = {
5628 (char *) "self",(char *) "x",(char *) "y", NULL
5629 };
5630
5631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5633 if (!SWIG_IsOK(res1)) {
5634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5635 }
5636 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5637 ecode2 = SWIG_AsVal_double(obj1, &val2);
5638 if (!SWIG_IsOK(ecode2)) {
5639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5640 }
5641 arg2 = static_cast< double >(val2);
5642 ecode3 = SWIG_AsVal_double(obj2, &val3);
5643 if (!SWIG_IsOK(ecode3)) {
5644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5645 }
5646 arg3 = static_cast< double >(val3);
5647 {
5648 PyThreadState* __tstate = wxPyBeginAllowThreads();
5649 wxRealPoint_Set(arg1,arg2,arg3);
5650 wxPyEndAllowThreads(__tstate);
5651 if (PyErr_Occurred()) SWIG_fail;
5652 }
5653 resultobj = SWIG_Py_Void();
5654 return resultobj;
5655 fail:
5656 return NULL;
5657 }
5658
5659
5660 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5661 PyObject *resultobj = 0;
5662 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5663 PyObject *result = 0 ;
5664 void *argp1 = 0 ;
5665 int res1 = 0 ;
5666 PyObject *swig_obj[1] ;
5667
5668 if (!args) SWIG_fail;
5669 swig_obj[0] = args;
5670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5671 if (!SWIG_IsOK(res1)) {
5672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5673 }
5674 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5675 {
5676 PyThreadState* __tstate = wxPyBeginAllowThreads();
5677 result = (PyObject *)wxRealPoint_Get(arg1);
5678 wxPyEndAllowThreads(__tstate);
5679 if (PyErr_Occurred()) SWIG_fail;
5680 }
5681 resultobj = result;
5682 return resultobj;
5683 fail:
5684 return NULL;
5685 }
5686
5687
5688 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5689 PyObject *obj;
5690 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5691 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5692 return SWIG_Py_Void();
5693 }
5694
5695 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5696 return SWIG_Python_InitShadowInstance(args);
5697 }
5698
5699 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5700 PyObject *resultobj = 0;
5701 wxPoint *arg1 = (wxPoint *) 0 ;
5702 int arg2 ;
5703 void *argp1 = 0 ;
5704 int res1 = 0 ;
5705 int val2 ;
5706 int ecode2 = 0 ;
5707 PyObject *swig_obj[2] ;
5708
5709 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5711 if (!SWIG_IsOK(res1)) {
5712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5713 }
5714 arg1 = reinterpret_cast< wxPoint * >(argp1);
5715 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5716 if (!SWIG_IsOK(ecode2)) {
5717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5718 }
5719 arg2 = static_cast< int >(val2);
5720 if (arg1) (arg1)->x = arg2;
5721
5722 resultobj = SWIG_Py_Void();
5723 return resultobj;
5724 fail:
5725 return NULL;
5726 }
5727
5728
5729 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5730 PyObject *resultobj = 0;
5731 wxPoint *arg1 = (wxPoint *) 0 ;
5732 int result;
5733 void *argp1 = 0 ;
5734 int res1 = 0 ;
5735 PyObject *swig_obj[1] ;
5736
5737 if (!args) SWIG_fail;
5738 swig_obj[0] = args;
5739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5740 if (!SWIG_IsOK(res1)) {
5741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5742 }
5743 arg1 = reinterpret_cast< wxPoint * >(argp1);
5744 result = (int) ((arg1)->x);
5745 resultobj = SWIG_From_int(static_cast< int >(result));
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5753 PyObject *resultobj = 0;
5754 wxPoint *arg1 = (wxPoint *) 0 ;
5755 int arg2 ;
5756 void *argp1 = 0 ;
5757 int res1 = 0 ;
5758 int val2 ;
5759 int ecode2 = 0 ;
5760 PyObject *swig_obj[2] ;
5761
5762 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5764 if (!SWIG_IsOK(res1)) {
5765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5766 }
5767 arg1 = reinterpret_cast< wxPoint * >(argp1);
5768 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5769 if (!SWIG_IsOK(ecode2)) {
5770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5771 }
5772 arg2 = static_cast< int >(val2);
5773 if (arg1) (arg1)->y = arg2;
5774
5775 resultobj = SWIG_Py_Void();
5776 return resultobj;
5777 fail:
5778 return NULL;
5779 }
5780
5781
5782 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5783 PyObject *resultobj = 0;
5784 wxPoint *arg1 = (wxPoint *) 0 ;
5785 int result;
5786 void *argp1 = 0 ;
5787 int res1 = 0 ;
5788 PyObject *swig_obj[1] ;
5789
5790 if (!args) SWIG_fail;
5791 swig_obj[0] = args;
5792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5793 if (!SWIG_IsOK(res1)) {
5794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5795 }
5796 arg1 = reinterpret_cast< wxPoint * >(argp1);
5797 result = (int) ((arg1)->y);
5798 resultobj = SWIG_From_int(static_cast< int >(result));
5799 return resultobj;
5800 fail:
5801 return NULL;
5802 }
5803
5804
5805 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5806 PyObject *resultobj = 0;
5807 int arg1 = (int) 0 ;
5808 int arg2 = (int) 0 ;
5809 wxPoint *result = 0 ;
5810 int val1 ;
5811 int ecode1 = 0 ;
5812 int val2 ;
5813 int ecode2 = 0 ;
5814 PyObject * obj0 = 0 ;
5815 PyObject * obj1 = 0 ;
5816 char * kwnames[] = {
5817 (char *) "x",(char *) "y", NULL
5818 };
5819
5820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5821 if (obj0) {
5822 ecode1 = SWIG_AsVal_int(obj0, &val1);
5823 if (!SWIG_IsOK(ecode1)) {
5824 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5825 }
5826 arg1 = static_cast< int >(val1);
5827 }
5828 if (obj1) {
5829 ecode2 = SWIG_AsVal_int(obj1, &val2);
5830 if (!SWIG_IsOK(ecode2)) {
5831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5832 }
5833 arg2 = static_cast< int >(val2);
5834 }
5835 {
5836 PyThreadState* __tstate = wxPyBeginAllowThreads();
5837 result = (wxPoint *)new wxPoint(arg1,arg2);
5838 wxPyEndAllowThreads(__tstate);
5839 if (PyErr_Occurred()) SWIG_fail;
5840 }
5841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5842 return resultobj;
5843 fail:
5844 return NULL;
5845 }
5846
5847
5848 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5849 PyObject *resultobj = 0;
5850 wxPoint *arg1 = (wxPoint *) 0 ;
5851 void *argp1 = 0 ;
5852 int res1 = 0 ;
5853 PyObject *swig_obj[1] ;
5854
5855 if (!args) SWIG_fail;
5856 swig_obj[0] = args;
5857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5858 if (!SWIG_IsOK(res1)) {
5859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5860 }
5861 arg1 = reinterpret_cast< wxPoint * >(argp1);
5862 {
5863 PyThreadState* __tstate = wxPyBeginAllowThreads();
5864 delete arg1;
5865
5866 wxPyEndAllowThreads(__tstate);
5867 if (PyErr_Occurred()) SWIG_fail;
5868 }
5869 resultobj = SWIG_Py_Void();
5870 return resultobj;
5871 fail:
5872 return NULL;
5873 }
5874
5875
5876 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5877 PyObject *resultobj = 0;
5878 wxPoint *arg1 = (wxPoint *) 0 ;
5879 PyObject *arg2 = (PyObject *) 0 ;
5880 bool result;
5881 void *argp1 = 0 ;
5882 int res1 = 0 ;
5883 PyObject * obj0 = 0 ;
5884 PyObject * obj1 = 0 ;
5885 char * kwnames[] = {
5886 (char *) "self",(char *) "other", NULL
5887 };
5888
5889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5891 if (!SWIG_IsOK(res1)) {
5892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5893 }
5894 arg1 = reinterpret_cast< wxPoint * >(argp1);
5895 arg2 = obj1;
5896 {
5897 result = (bool)wxPoint___eq__(arg1,arg2);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 {
5901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5902 }
5903 return resultobj;
5904 fail:
5905 return NULL;
5906 }
5907
5908
5909 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5910 PyObject *resultobj = 0;
5911 wxPoint *arg1 = (wxPoint *) 0 ;
5912 PyObject *arg2 = (PyObject *) 0 ;
5913 bool result;
5914 void *argp1 = 0 ;
5915 int res1 = 0 ;
5916 PyObject * obj0 = 0 ;
5917 PyObject * obj1 = 0 ;
5918 char * kwnames[] = {
5919 (char *) "self",(char *) "other", NULL
5920 };
5921
5922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5924 if (!SWIG_IsOK(res1)) {
5925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5926 }
5927 arg1 = reinterpret_cast< wxPoint * >(argp1);
5928 arg2 = obj1;
5929 {
5930 result = (bool)wxPoint___ne__(arg1,arg2);
5931 if (PyErr_Occurred()) SWIG_fail;
5932 }
5933 {
5934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5935 }
5936 return resultobj;
5937 fail:
5938 return NULL;
5939 }
5940
5941
5942 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5943 PyObject *resultobj = 0;
5944 wxPoint *arg1 = (wxPoint *) 0 ;
5945 wxPoint *arg2 = 0 ;
5946 wxPoint result;
5947 void *argp1 = 0 ;
5948 int res1 = 0 ;
5949 wxPoint temp2 ;
5950 PyObject * obj0 = 0 ;
5951 PyObject * obj1 = 0 ;
5952 char * kwnames[] = {
5953 (char *) "self",(char *) "pt", NULL
5954 };
5955
5956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5958 if (!SWIG_IsOK(res1)) {
5959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5960 }
5961 arg1 = reinterpret_cast< wxPoint * >(argp1);
5962 {
5963 arg2 = &temp2;
5964 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5965 }
5966 {
5967 PyThreadState* __tstate = wxPyBeginAllowThreads();
5968 result = (arg1)->operator +((wxPoint const &)*arg2);
5969 wxPyEndAllowThreads(__tstate);
5970 if (PyErr_Occurred()) SWIG_fail;
5971 }
5972 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5973 return resultobj;
5974 fail:
5975 return NULL;
5976 }
5977
5978
5979 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5980 PyObject *resultobj = 0;
5981 wxPoint *arg1 = (wxPoint *) 0 ;
5982 wxPoint *arg2 = 0 ;
5983 wxPoint result;
5984 void *argp1 = 0 ;
5985 int res1 = 0 ;
5986 wxPoint temp2 ;
5987 PyObject * obj0 = 0 ;
5988 PyObject * obj1 = 0 ;
5989 char * kwnames[] = {
5990 (char *) "self",(char *) "pt", NULL
5991 };
5992
5993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5995 if (!SWIG_IsOK(res1)) {
5996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5997 }
5998 arg1 = reinterpret_cast< wxPoint * >(argp1);
5999 {
6000 arg2 = &temp2;
6001 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6002 }
6003 {
6004 PyThreadState* __tstate = wxPyBeginAllowThreads();
6005 result = (arg1)->operator -((wxPoint const &)*arg2);
6006 wxPyEndAllowThreads(__tstate);
6007 if (PyErr_Occurred()) SWIG_fail;
6008 }
6009 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6010 return resultobj;
6011 fail:
6012 return NULL;
6013 }
6014
6015
6016 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6017 PyObject *resultobj = 0;
6018 wxPoint *arg1 = (wxPoint *) 0 ;
6019 wxPoint *arg2 = 0 ;
6020 wxPoint *result = 0 ;
6021 void *argp1 = 0 ;
6022 int res1 = 0 ;
6023 wxPoint temp2 ;
6024 PyObject * obj0 = 0 ;
6025 PyObject * obj1 = 0 ;
6026 char * kwnames[] = {
6027 (char *) "self",(char *) "pt", NULL
6028 };
6029
6030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6032 if (!SWIG_IsOK(res1)) {
6033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6034 }
6035 arg1 = reinterpret_cast< wxPoint * >(argp1);
6036 {
6037 arg2 = &temp2;
6038 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6039 }
6040 {
6041 PyThreadState* __tstate = wxPyBeginAllowThreads();
6042 {
6043 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6044 result = (wxPoint *) &_result_ref;
6045 }
6046 wxPyEndAllowThreads(__tstate);
6047 if (PyErr_Occurred()) SWIG_fail;
6048 }
6049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6050 return resultobj;
6051 fail:
6052 return NULL;
6053 }
6054
6055
6056 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6057 PyObject *resultobj = 0;
6058 wxPoint *arg1 = (wxPoint *) 0 ;
6059 wxPoint *arg2 = 0 ;
6060 wxPoint *result = 0 ;
6061 void *argp1 = 0 ;
6062 int res1 = 0 ;
6063 wxPoint temp2 ;
6064 PyObject * obj0 = 0 ;
6065 PyObject * obj1 = 0 ;
6066 char * kwnames[] = {
6067 (char *) "self",(char *) "pt", NULL
6068 };
6069
6070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6072 if (!SWIG_IsOK(res1)) {
6073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6074 }
6075 arg1 = reinterpret_cast< wxPoint * >(argp1);
6076 {
6077 arg2 = &temp2;
6078 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6079 }
6080 {
6081 PyThreadState* __tstate = wxPyBeginAllowThreads();
6082 {
6083 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6084 result = (wxPoint *) &_result_ref;
6085 }
6086 wxPyEndAllowThreads(__tstate);
6087 if (PyErr_Occurred()) SWIG_fail;
6088 }
6089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6090 return resultobj;
6091 fail:
6092 return NULL;
6093 }
6094
6095
6096 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6097 PyObject *resultobj = 0;
6098 wxPoint *arg1 = (wxPoint *) 0 ;
6099 long arg2 ;
6100 long arg3 ;
6101 void *argp1 = 0 ;
6102 int res1 = 0 ;
6103 long val2 ;
6104 int ecode2 = 0 ;
6105 long val3 ;
6106 int ecode3 = 0 ;
6107 PyObject * obj0 = 0 ;
6108 PyObject * obj1 = 0 ;
6109 PyObject * obj2 = 0 ;
6110 char * kwnames[] = {
6111 (char *) "self",(char *) "x",(char *) "y", NULL
6112 };
6113
6114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6116 if (!SWIG_IsOK(res1)) {
6117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6118 }
6119 arg1 = reinterpret_cast< wxPoint * >(argp1);
6120 ecode2 = SWIG_AsVal_long(obj1, &val2);
6121 if (!SWIG_IsOK(ecode2)) {
6122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6123 }
6124 arg2 = static_cast< long >(val2);
6125 ecode3 = SWIG_AsVal_long(obj2, &val3);
6126 if (!SWIG_IsOK(ecode3)) {
6127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6128 }
6129 arg3 = static_cast< long >(val3);
6130 {
6131 PyThreadState* __tstate = wxPyBeginAllowThreads();
6132 wxPoint_Set(arg1,arg2,arg3);
6133 wxPyEndAllowThreads(__tstate);
6134 if (PyErr_Occurred()) SWIG_fail;
6135 }
6136 resultobj = SWIG_Py_Void();
6137 return resultobj;
6138 fail:
6139 return NULL;
6140 }
6141
6142
6143 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6144 PyObject *resultobj = 0;
6145 wxPoint *arg1 = (wxPoint *) 0 ;
6146 PyObject *result = 0 ;
6147 void *argp1 = 0 ;
6148 int res1 = 0 ;
6149 PyObject *swig_obj[1] ;
6150
6151 if (!args) SWIG_fail;
6152 swig_obj[0] = args;
6153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6154 if (!SWIG_IsOK(res1)) {
6155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6156 }
6157 arg1 = reinterpret_cast< wxPoint * >(argp1);
6158 {
6159 PyThreadState* __tstate = wxPyBeginAllowThreads();
6160 result = (PyObject *)wxPoint_Get(arg1);
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 resultobj = result;
6165 return resultobj;
6166 fail:
6167 return NULL;
6168 }
6169
6170
6171 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6172 PyObject *obj;
6173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6174 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6175 return SWIG_Py_Void();
6176 }
6177
6178 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6179 return SWIG_Python_InitShadowInstance(args);
6180 }
6181
6182 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6183 PyObject *resultobj = 0;
6184 int arg1 = (int) 0 ;
6185 int arg2 = (int) 0 ;
6186 int arg3 = (int) 0 ;
6187 int arg4 = (int) 0 ;
6188 wxRect *result = 0 ;
6189 int val1 ;
6190 int ecode1 = 0 ;
6191 int val2 ;
6192 int ecode2 = 0 ;
6193 int val3 ;
6194 int ecode3 = 0 ;
6195 int val4 ;
6196 int ecode4 = 0 ;
6197 PyObject * obj0 = 0 ;
6198 PyObject * obj1 = 0 ;
6199 PyObject * obj2 = 0 ;
6200 PyObject * obj3 = 0 ;
6201 char * kwnames[] = {
6202 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6203 };
6204
6205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6206 if (obj0) {
6207 ecode1 = SWIG_AsVal_int(obj0, &val1);
6208 if (!SWIG_IsOK(ecode1)) {
6209 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6210 }
6211 arg1 = static_cast< int >(val1);
6212 }
6213 if (obj1) {
6214 ecode2 = SWIG_AsVal_int(obj1, &val2);
6215 if (!SWIG_IsOK(ecode2)) {
6216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6217 }
6218 arg2 = static_cast< int >(val2);
6219 }
6220 if (obj2) {
6221 ecode3 = SWIG_AsVal_int(obj2, &val3);
6222 if (!SWIG_IsOK(ecode3)) {
6223 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6224 }
6225 arg3 = static_cast< int >(val3);
6226 }
6227 if (obj3) {
6228 ecode4 = SWIG_AsVal_int(obj3, &val4);
6229 if (!SWIG_IsOK(ecode4)) {
6230 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6231 }
6232 arg4 = static_cast< int >(val4);
6233 }
6234 {
6235 PyThreadState* __tstate = wxPyBeginAllowThreads();
6236 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6237 wxPyEndAllowThreads(__tstate);
6238 if (PyErr_Occurred()) SWIG_fail;
6239 }
6240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6241 return resultobj;
6242 fail:
6243 return NULL;
6244 }
6245
6246
6247 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6248 PyObject *resultobj = 0;
6249 wxPoint *arg1 = 0 ;
6250 wxPoint *arg2 = 0 ;
6251 wxRect *result = 0 ;
6252 wxPoint temp1 ;
6253 wxPoint temp2 ;
6254 PyObject * obj0 = 0 ;
6255 PyObject * obj1 = 0 ;
6256 char * kwnames[] = {
6257 (char *) "topLeft",(char *) "bottomRight", NULL
6258 };
6259
6260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6261 {
6262 arg1 = &temp1;
6263 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6264 }
6265 {
6266 arg2 = &temp2;
6267 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6268 }
6269 {
6270 PyThreadState* __tstate = wxPyBeginAllowThreads();
6271 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6272 wxPyEndAllowThreads(__tstate);
6273 if (PyErr_Occurred()) SWIG_fail;
6274 }
6275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6276 return resultobj;
6277 fail:
6278 return NULL;
6279 }
6280
6281
6282 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6283 PyObject *resultobj = 0;
6284 wxPoint *arg1 = 0 ;
6285 wxSize *arg2 = 0 ;
6286 wxRect *result = 0 ;
6287 wxPoint temp1 ;
6288 wxSize temp2 ;
6289 PyObject * obj0 = 0 ;
6290 PyObject * obj1 = 0 ;
6291 char * kwnames[] = {
6292 (char *) "pos",(char *) "size", NULL
6293 };
6294
6295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6296 {
6297 arg1 = &temp1;
6298 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6299 }
6300 {
6301 arg2 = &temp2;
6302 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6303 }
6304 {
6305 PyThreadState* __tstate = wxPyBeginAllowThreads();
6306 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6307 wxPyEndAllowThreads(__tstate);
6308 if (PyErr_Occurred()) SWIG_fail;
6309 }
6310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6311 return resultobj;
6312 fail:
6313 return NULL;
6314 }
6315
6316
6317 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6318 PyObject *resultobj = 0;
6319 wxSize *arg1 = 0 ;
6320 wxRect *result = 0 ;
6321 wxSize temp1 ;
6322 PyObject * obj0 = 0 ;
6323 char * kwnames[] = {
6324 (char *) "size", NULL
6325 };
6326
6327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6328 {
6329 arg1 = &temp1;
6330 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6331 }
6332 {
6333 PyThreadState* __tstate = wxPyBeginAllowThreads();
6334 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6335 wxPyEndAllowThreads(__tstate);
6336 if (PyErr_Occurred()) SWIG_fail;
6337 }
6338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6339 return resultobj;
6340 fail:
6341 return NULL;
6342 }
6343
6344
6345 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6346 PyObject *resultobj = 0;
6347 wxRect *arg1 = (wxRect *) 0 ;
6348 void *argp1 = 0 ;
6349 int res1 = 0 ;
6350 PyObject *swig_obj[1] ;
6351
6352 if (!args) SWIG_fail;
6353 swig_obj[0] = args;
6354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6355 if (!SWIG_IsOK(res1)) {
6356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6357 }
6358 arg1 = reinterpret_cast< wxRect * >(argp1);
6359 {
6360 PyThreadState* __tstate = wxPyBeginAllowThreads();
6361 delete arg1;
6362
6363 wxPyEndAllowThreads(__tstate);
6364 if (PyErr_Occurred()) SWIG_fail;
6365 }
6366 resultobj = SWIG_Py_Void();
6367 return resultobj;
6368 fail:
6369 return NULL;
6370 }
6371
6372
6373 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6374 PyObject *resultobj = 0;
6375 wxRect *arg1 = (wxRect *) 0 ;
6376 int result;
6377 void *argp1 = 0 ;
6378 int res1 = 0 ;
6379 PyObject *swig_obj[1] ;
6380
6381 if (!args) SWIG_fail;
6382 swig_obj[0] = args;
6383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6384 if (!SWIG_IsOK(res1)) {
6385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6386 }
6387 arg1 = reinterpret_cast< wxRect * >(argp1);
6388 {
6389 PyThreadState* __tstate = wxPyBeginAllowThreads();
6390 result = (int)((wxRect const *)arg1)->GetX();
6391 wxPyEndAllowThreads(__tstate);
6392 if (PyErr_Occurred()) SWIG_fail;
6393 }
6394 resultobj = SWIG_From_int(static_cast< int >(result));
6395 return resultobj;
6396 fail:
6397 return NULL;
6398 }
6399
6400
6401 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj = 0;
6403 wxRect *arg1 = (wxRect *) 0 ;
6404 int arg2 ;
6405 void *argp1 = 0 ;
6406 int res1 = 0 ;
6407 int val2 ;
6408 int ecode2 = 0 ;
6409 PyObject * obj0 = 0 ;
6410 PyObject * obj1 = 0 ;
6411 char * kwnames[] = {
6412 (char *) "self",(char *) "x", NULL
6413 };
6414
6415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6417 if (!SWIG_IsOK(res1)) {
6418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6419 }
6420 arg1 = reinterpret_cast< wxRect * >(argp1);
6421 ecode2 = SWIG_AsVal_int(obj1, &val2);
6422 if (!SWIG_IsOK(ecode2)) {
6423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6424 }
6425 arg2 = static_cast< int >(val2);
6426 {
6427 PyThreadState* __tstate = wxPyBeginAllowThreads();
6428 (arg1)->SetX(arg2);
6429 wxPyEndAllowThreads(__tstate);
6430 if (PyErr_Occurred()) SWIG_fail;
6431 }
6432 resultobj = SWIG_Py_Void();
6433 return resultobj;
6434 fail:
6435 return NULL;
6436 }
6437
6438
6439 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6440 PyObject *resultobj = 0;
6441 wxRect *arg1 = (wxRect *) 0 ;
6442 int result;
6443 void *argp1 = 0 ;
6444 int res1 = 0 ;
6445 PyObject *swig_obj[1] ;
6446
6447 if (!args) SWIG_fail;
6448 swig_obj[0] = args;
6449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6450 if (!SWIG_IsOK(res1)) {
6451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6452 }
6453 arg1 = reinterpret_cast< wxRect * >(argp1);
6454 {
6455 PyThreadState* __tstate = wxPyBeginAllowThreads();
6456 result = (int)(arg1)->GetY();
6457 wxPyEndAllowThreads(__tstate);
6458 if (PyErr_Occurred()) SWIG_fail;
6459 }
6460 resultobj = SWIG_From_int(static_cast< int >(result));
6461 return resultobj;
6462 fail:
6463 return NULL;
6464 }
6465
6466
6467 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6468 PyObject *resultobj = 0;
6469 wxRect *arg1 = (wxRect *) 0 ;
6470 int arg2 ;
6471 void *argp1 = 0 ;
6472 int res1 = 0 ;
6473 int val2 ;
6474 int ecode2 = 0 ;
6475 PyObject * obj0 = 0 ;
6476 PyObject * obj1 = 0 ;
6477 char * kwnames[] = {
6478 (char *) "self",(char *) "y", NULL
6479 };
6480
6481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6483 if (!SWIG_IsOK(res1)) {
6484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6485 }
6486 arg1 = reinterpret_cast< wxRect * >(argp1);
6487 ecode2 = SWIG_AsVal_int(obj1, &val2);
6488 if (!SWIG_IsOK(ecode2)) {
6489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6490 }
6491 arg2 = static_cast< int >(val2);
6492 {
6493 PyThreadState* __tstate = wxPyBeginAllowThreads();
6494 (arg1)->SetY(arg2);
6495 wxPyEndAllowThreads(__tstate);
6496 if (PyErr_Occurred()) SWIG_fail;
6497 }
6498 resultobj = SWIG_Py_Void();
6499 return resultobj;
6500 fail:
6501 return NULL;
6502 }
6503
6504
6505 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6506 PyObject *resultobj = 0;
6507 wxRect *arg1 = (wxRect *) 0 ;
6508 int result;
6509 void *argp1 = 0 ;
6510 int res1 = 0 ;
6511 PyObject *swig_obj[1] ;
6512
6513 if (!args) SWIG_fail;
6514 swig_obj[0] = args;
6515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6516 if (!SWIG_IsOK(res1)) {
6517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6518 }
6519 arg1 = reinterpret_cast< wxRect * >(argp1);
6520 {
6521 PyThreadState* __tstate = wxPyBeginAllowThreads();
6522 result = (int)((wxRect const *)arg1)->GetWidth();
6523 wxPyEndAllowThreads(__tstate);
6524 if (PyErr_Occurred()) SWIG_fail;
6525 }
6526 resultobj = SWIG_From_int(static_cast< int >(result));
6527 return resultobj;
6528 fail:
6529 return NULL;
6530 }
6531
6532
6533 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6534 PyObject *resultobj = 0;
6535 wxRect *arg1 = (wxRect *) 0 ;
6536 int arg2 ;
6537 void *argp1 = 0 ;
6538 int res1 = 0 ;
6539 int val2 ;
6540 int ecode2 = 0 ;
6541 PyObject * obj0 = 0 ;
6542 PyObject * obj1 = 0 ;
6543 char * kwnames[] = {
6544 (char *) "self",(char *) "w", NULL
6545 };
6546
6547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6549 if (!SWIG_IsOK(res1)) {
6550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6551 }
6552 arg1 = reinterpret_cast< wxRect * >(argp1);
6553 ecode2 = SWIG_AsVal_int(obj1, &val2);
6554 if (!SWIG_IsOK(ecode2)) {
6555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6556 }
6557 arg2 = static_cast< int >(val2);
6558 {
6559 PyThreadState* __tstate = wxPyBeginAllowThreads();
6560 (arg1)->SetWidth(arg2);
6561 wxPyEndAllowThreads(__tstate);
6562 if (PyErr_Occurred()) SWIG_fail;
6563 }
6564 resultobj = SWIG_Py_Void();
6565 return resultobj;
6566 fail:
6567 return NULL;
6568 }
6569
6570
6571 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6572 PyObject *resultobj = 0;
6573 wxRect *arg1 = (wxRect *) 0 ;
6574 int result;
6575 void *argp1 = 0 ;
6576 int res1 = 0 ;
6577 PyObject *swig_obj[1] ;
6578
6579 if (!args) SWIG_fail;
6580 swig_obj[0] = args;
6581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6582 if (!SWIG_IsOK(res1)) {
6583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6584 }
6585 arg1 = reinterpret_cast< wxRect * >(argp1);
6586 {
6587 PyThreadState* __tstate = wxPyBeginAllowThreads();
6588 result = (int)((wxRect const *)arg1)->GetHeight();
6589 wxPyEndAllowThreads(__tstate);
6590 if (PyErr_Occurred()) SWIG_fail;
6591 }
6592 resultobj = SWIG_From_int(static_cast< int >(result));
6593 return resultobj;
6594 fail:
6595 return NULL;
6596 }
6597
6598
6599 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6600 PyObject *resultobj = 0;
6601 wxRect *arg1 = (wxRect *) 0 ;
6602 int arg2 ;
6603 void *argp1 = 0 ;
6604 int res1 = 0 ;
6605 int val2 ;
6606 int ecode2 = 0 ;
6607 PyObject * obj0 = 0 ;
6608 PyObject * obj1 = 0 ;
6609 char * kwnames[] = {
6610 (char *) "self",(char *) "h", NULL
6611 };
6612
6613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6615 if (!SWIG_IsOK(res1)) {
6616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6617 }
6618 arg1 = reinterpret_cast< wxRect * >(argp1);
6619 ecode2 = SWIG_AsVal_int(obj1, &val2);
6620 if (!SWIG_IsOK(ecode2)) {
6621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6622 }
6623 arg2 = static_cast< int >(val2);
6624 {
6625 PyThreadState* __tstate = wxPyBeginAllowThreads();
6626 (arg1)->SetHeight(arg2);
6627 wxPyEndAllowThreads(__tstate);
6628 if (PyErr_Occurred()) SWIG_fail;
6629 }
6630 resultobj = SWIG_Py_Void();
6631 return resultobj;
6632 fail:
6633 return NULL;
6634 }
6635
6636
6637 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6638 PyObject *resultobj = 0;
6639 wxRect *arg1 = (wxRect *) 0 ;
6640 wxPoint result;
6641 void *argp1 = 0 ;
6642 int res1 = 0 ;
6643 PyObject *swig_obj[1] ;
6644
6645 if (!args) SWIG_fail;
6646 swig_obj[0] = args;
6647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6648 if (!SWIG_IsOK(res1)) {
6649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6650 }
6651 arg1 = reinterpret_cast< wxRect * >(argp1);
6652 {
6653 PyThreadState* __tstate = wxPyBeginAllowThreads();
6654 result = ((wxRect const *)arg1)->GetPosition();
6655 wxPyEndAllowThreads(__tstate);
6656 if (PyErr_Occurred()) SWIG_fail;
6657 }
6658 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6659 return resultobj;
6660 fail:
6661 return NULL;
6662 }
6663
6664
6665 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6666 PyObject *resultobj = 0;
6667 wxRect *arg1 = (wxRect *) 0 ;
6668 wxPoint *arg2 = 0 ;
6669 void *argp1 = 0 ;
6670 int res1 = 0 ;
6671 wxPoint temp2 ;
6672 PyObject * obj0 = 0 ;
6673 PyObject * obj1 = 0 ;
6674 char * kwnames[] = {
6675 (char *) "self",(char *) "p", NULL
6676 };
6677
6678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6680 if (!SWIG_IsOK(res1)) {
6681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6682 }
6683 arg1 = reinterpret_cast< wxRect * >(argp1);
6684 {
6685 arg2 = &temp2;
6686 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6687 }
6688 {
6689 PyThreadState* __tstate = wxPyBeginAllowThreads();
6690 (arg1)->SetPosition((wxPoint const &)*arg2);
6691 wxPyEndAllowThreads(__tstate);
6692 if (PyErr_Occurred()) SWIG_fail;
6693 }
6694 resultobj = SWIG_Py_Void();
6695 return resultobj;
6696 fail:
6697 return NULL;
6698 }
6699
6700
6701 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6702 PyObject *resultobj = 0;
6703 wxRect *arg1 = (wxRect *) 0 ;
6704 wxSize result;
6705 void *argp1 = 0 ;
6706 int res1 = 0 ;
6707 PyObject *swig_obj[1] ;
6708
6709 if (!args) SWIG_fail;
6710 swig_obj[0] = args;
6711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6712 if (!SWIG_IsOK(res1)) {
6713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6714 }
6715 arg1 = reinterpret_cast< wxRect * >(argp1);
6716 {
6717 PyThreadState* __tstate = wxPyBeginAllowThreads();
6718 result = ((wxRect const *)arg1)->GetSize();
6719 wxPyEndAllowThreads(__tstate);
6720 if (PyErr_Occurred()) SWIG_fail;
6721 }
6722 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6723 return resultobj;
6724 fail:
6725 return NULL;
6726 }
6727
6728
6729 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6730 PyObject *resultobj = 0;
6731 wxRect *arg1 = (wxRect *) 0 ;
6732 wxSize *arg2 = 0 ;
6733 void *argp1 = 0 ;
6734 int res1 = 0 ;
6735 wxSize temp2 ;
6736 PyObject * obj0 = 0 ;
6737 PyObject * obj1 = 0 ;
6738 char * kwnames[] = {
6739 (char *) "self",(char *) "s", NULL
6740 };
6741
6742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6744 if (!SWIG_IsOK(res1)) {
6745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6746 }
6747 arg1 = reinterpret_cast< wxRect * >(argp1);
6748 {
6749 arg2 = &temp2;
6750 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6751 }
6752 {
6753 PyThreadState* __tstate = wxPyBeginAllowThreads();
6754 (arg1)->SetSize((wxSize const &)*arg2);
6755 wxPyEndAllowThreads(__tstate);
6756 if (PyErr_Occurred()) SWIG_fail;
6757 }
6758 resultobj = SWIG_Py_Void();
6759 return resultobj;
6760 fail:
6761 return NULL;
6762 }
6763
6764
6765 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6766 PyObject *resultobj = 0;
6767 wxRect *arg1 = (wxRect *) 0 ;
6768 bool result;
6769 void *argp1 = 0 ;
6770 int res1 = 0 ;
6771 PyObject *swig_obj[1] ;
6772
6773 if (!args) SWIG_fail;
6774 swig_obj[0] = args;
6775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6776 if (!SWIG_IsOK(res1)) {
6777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6778 }
6779 arg1 = reinterpret_cast< wxRect * >(argp1);
6780 {
6781 PyThreadState* __tstate = wxPyBeginAllowThreads();
6782 result = (bool)((wxRect const *)arg1)->IsEmpty();
6783 wxPyEndAllowThreads(__tstate);
6784 if (PyErr_Occurred()) SWIG_fail;
6785 }
6786 {
6787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6788 }
6789 return resultobj;
6790 fail:
6791 return NULL;
6792 }
6793
6794
6795 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6796 PyObject *resultobj = 0;
6797 wxRect *arg1 = (wxRect *) 0 ;
6798 wxPoint result;
6799 void *argp1 = 0 ;
6800 int res1 = 0 ;
6801 PyObject *swig_obj[1] ;
6802
6803 if (!args) SWIG_fail;
6804 swig_obj[0] = args;
6805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6806 if (!SWIG_IsOK(res1)) {
6807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6808 }
6809 arg1 = reinterpret_cast< wxRect * >(argp1);
6810 {
6811 PyThreadState* __tstate = wxPyBeginAllowThreads();
6812 result = ((wxRect const *)arg1)->GetTopLeft();
6813 wxPyEndAllowThreads(__tstate);
6814 if (PyErr_Occurred()) SWIG_fail;
6815 }
6816 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6817 return resultobj;
6818 fail:
6819 return NULL;
6820 }
6821
6822
6823 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6824 PyObject *resultobj = 0;
6825 wxRect *arg1 = (wxRect *) 0 ;
6826 wxPoint *arg2 = 0 ;
6827 void *argp1 = 0 ;
6828 int res1 = 0 ;
6829 wxPoint temp2 ;
6830 PyObject * obj0 = 0 ;
6831 PyObject * obj1 = 0 ;
6832 char * kwnames[] = {
6833 (char *) "self",(char *) "p", NULL
6834 };
6835
6836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6838 if (!SWIG_IsOK(res1)) {
6839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6840 }
6841 arg1 = reinterpret_cast< wxRect * >(argp1);
6842 {
6843 arg2 = &temp2;
6844 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6845 }
6846 {
6847 PyThreadState* __tstate = wxPyBeginAllowThreads();
6848 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6849 wxPyEndAllowThreads(__tstate);
6850 if (PyErr_Occurred()) SWIG_fail;
6851 }
6852 resultobj = SWIG_Py_Void();
6853 return resultobj;
6854 fail:
6855 return NULL;
6856 }
6857
6858
6859 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6860 PyObject *resultobj = 0;
6861 wxRect *arg1 = (wxRect *) 0 ;
6862 wxPoint result;
6863 void *argp1 = 0 ;
6864 int res1 = 0 ;
6865 PyObject *swig_obj[1] ;
6866
6867 if (!args) SWIG_fail;
6868 swig_obj[0] = args;
6869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6870 if (!SWIG_IsOK(res1)) {
6871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6872 }
6873 arg1 = reinterpret_cast< wxRect * >(argp1);
6874 {
6875 PyThreadState* __tstate = wxPyBeginAllowThreads();
6876 result = ((wxRect const *)arg1)->GetBottomRight();
6877 wxPyEndAllowThreads(__tstate);
6878 if (PyErr_Occurred()) SWIG_fail;
6879 }
6880 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6881 return resultobj;
6882 fail:
6883 return NULL;
6884 }
6885
6886
6887 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6888 PyObject *resultobj = 0;
6889 wxRect *arg1 = (wxRect *) 0 ;
6890 wxPoint *arg2 = 0 ;
6891 void *argp1 = 0 ;
6892 int res1 = 0 ;
6893 wxPoint temp2 ;
6894 PyObject * obj0 = 0 ;
6895 PyObject * obj1 = 0 ;
6896 char * kwnames[] = {
6897 (char *) "self",(char *) "p", NULL
6898 };
6899
6900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6902 if (!SWIG_IsOK(res1)) {
6903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6904 }
6905 arg1 = reinterpret_cast< wxRect * >(argp1);
6906 {
6907 arg2 = &temp2;
6908 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6909 }
6910 {
6911 PyThreadState* __tstate = wxPyBeginAllowThreads();
6912 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6913 wxPyEndAllowThreads(__tstate);
6914 if (PyErr_Occurred()) SWIG_fail;
6915 }
6916 resultobj = SWIG_Py_Void();
6917 return resultobj;
6918 fail:
6919 return NULL;
6920 }
6921
6922
6923 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6924 PyObject *resultobj = 0;
6925 wxRect *arg1 = (wxRect *) 0 ;
6926 wxPoint result;
6927 void *argp1 = 0 ;
6928 int res1 = 0 ;
6929 PyObject *swig_obj[1] ;
6930
6931 if (!args) SWIG_fail;
6932 swig_obj[0] = args;
6933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6934 if (!SWIG_IsOK(res1)) {
6935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6936 }
6937 arg1 = reinterpret_cast< wxRect * >(argp1);
6938 {
6939 PyThreadState* __tstate = wxPyBeginAllowThreads();
6940 result = ((wxRect const *)arg1)->GetTopRight();
6941 wxPyEndAllowThreads(__tstate);
6942 if (PyErr_Occurred()) SWIG_fail;
6943 }
6944 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6945 return resultobj;
6946 fail:
6947 return NULL;
6948 }
6949
6950
6951 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6952 PyObject *resultobj = 0;
6953 wxRect *arg1 = (wxRect *) 0 ;
6954 wxPoint *arg2 = 0 ;
6955 void *argp1 = 0 ;
6956 int res1 = 0 ;
6957 wxPoint temp2 ;
6958 PyObject * obj0 = 0 ;
6959 PyObject * obj1 = 0 ;
6960 char * kwnames[] = {
6961 (char *) "self",(char *) "p", NULL
6962 };
6963
6964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6966 if (!SWIG_IsOK(res1)) {
6967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6968 }
6969 arg1 = reinterpret_cast< wxRect * >(argp1);
6970 {
6971 arg2 = &temp2;
6972 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6973 }
6974 {
6975 PyThreadState* __tstate = wxPyBeginAllowThreads();
6976 (arg1)->SetTopRight((wxPoint const &)*arg2);
6977 wxPyEndAllowThreads(__tstate);
6978 if (PyErr_Occurred()) SWIG_fail;
6979 }
6980 resultobj = SWIG_Py_Void();
6981 return resultobj;
6982 fail:
6983 return NULL;
6984 }
6985
6986
6987 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6988 PyObject *resultobj = 0;
6989 wxRect *arg1 = (wxRect *) 0 ;
6990 wxPoint result;
6991 void *argp1 = 0 ;
6992 int res1 = 0 ;
6993 PyObject *swig_obj[1] ;
6994
6995 if (!args) SWIG_fail;
6996 swig_obj[0] = args;
6997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6998 if (!SWIG_IsOK(res1)) {
6999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7000 }
7001 arg1 = reinterpret_cast< wxRect * >(argp1);
7002 {
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 result = ((wxRect const *)arg1)->GetBottomLeft();
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7009 return resultobj;
7010 fail:
7011 return NULL;
7012 }
7013
7014
7015 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7016 PyObject *resultobj = 0;
7017 wxRect *arg1 = (wxRect *) 0 ;
7018 wxPoint *arg2 = 0 ;
7019 void *argp1 = 0 ;
7020 int res1 = 0 ;
7021 wxPoint temp2 ;
7022 PyObject * obj0 = 0 ;
7023 PyObject * obj1 = 0 ;
7024 char * kwnames[] = {
7025 (char *) "self",(char *) "p", NULL
7026 };
7027
7028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7030 if (!SWIG_IsOK(res1)) {
7031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7032 }
7033 arg1 = reinterpret_cast< wxRect * >(argp1);
7034 {
7035 arg2 = &temp2;
7036 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7037 }
7038 {
7039 PyThreadState* __tstate = wxPyBeginAllowThreads();
7040 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7041 wxPyEndAllowThreads(__tstate);
7042 if (PyErr_Occurred()) SWIG_fail;
7043 }
7044 resultobj = SWIG_Py_Void();
7045 return resultobj;
7046 fail:
7047 return NULL;
7048 }
7049
7050
7051 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7052 PyObject *resultobj = 0;
7053 wxRect *arg1 = (wxRect *) 0 ;
7054 int result;
7055 void *argp1 = 0 ;
7056 int res1 = 0 ;
7057 PyObject *swig_obj[1] ;
7058
7059 if (!args) SWIG_fail;
7060 swig_obj[0] = args;
7061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7062 if (!SWIG_IsOK(res1)) {
7063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7064 }
7065 arg1 = reinterpret_cast< wxRect * >(argp1);
7066 {
7067 PyThreadState* __tstate = wxPyBeginAllowThreads();
7068 result = (int)((wxRect const *)arg1)->GetLeft();
7069 wxPyEndAllowThreads(__tstate);
7070 if (PyErr_Occurred()) SWIG_fail;
7071 }
7072 resultobj = SWIG_From_int(static_cast< int >(result));
7073 return resultobj;
7074 fail:
7075 return NULL;
7076 }
7077
7078
7079 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7080 PyObject *resultobj = 0;
7081 wxRect *arg1 = (wxRect *) 0 ;
7082 int result;
7083 void *argp1 = 0 ;
7084 int res1 = 0 ;
7085 PyObject *swig_obj[1] ;
7086
7087 if (!args) SWIG_fail;
7088 swig_obj[0] = args;
7089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7090 if (!SWIG_IsOK(res1)) {
7091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7092 }
7093 arg1 = reinterpret_cast< wxRect * >(argp1);
7094 {
7095 PyThreadState* __tstate = wxPyBeginAllowThreads();
7096 result = (int)((wxRect const *)arg1)->GetTop();
7097 wxPyEndAllowThreads(__tstate);
7098 if (PyErr_Occurred()) SWIG_fail;
7099 }
7100 resultobj = SWIG_From_int(static_cast< int >(result));
7101 return resultobj;
7102 fail:
7103 return NULL;
7104 }
7105
7106
7107 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7108 PyObject *resultobj = 0;
7109 wxRect *arg1 = (wxRect *) 0 ;
7110 int result;
7111 void *argp1 = 0 ;
7112 int res1 = 0 ;
7113 PyObject *swig_obj[1] ;
7114
7115 if (!args) SWIG_fail;
7116 swig_obj[0] = args;
7117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7118 if (!SWIG_IsOK(res1)) {
7119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7120 }
7121 arg1 = reinterpret_cast< wxRect * >(argp1);
7122 {
7123 PyThreadState* __tstate = wxPyBeginAllowThreads();
7124 result = (int)((wxRect const *)arg1)->GetBottom();
7125 wxPyEndAllowThreads(__tstate);
7126 if (PyErr_Occurred()) SWIG_fail;
7127 }
7128 resultobj = SWIG_From_int(static_cast< int >(result));
7129 return resultobj;
7130 fail:
7131 return NULL;
7132 }
7133
7134
7135 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7136 PyObject *resultobj = 0;
7137 wxRect *arg1 = (wxRect *) 0 ;
7138 int result;
7139 void *argp1 = 0 ;
7140 int res1 = 0 ;
7141 PyObject *swig_obj[1] ;
7142
7143 if (!args) SWIG_fail;
7144 swig_obj[0] = args;
7145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7146 if (!SWIG_IsOK(res1)) {
7147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7148 }
7149 arg1 = reinterpret_cast< wxRect * >(argp1);
7150 {
7151 PyThreadState* __tstate = wxPyBeginAllowThreads();
7152 result = (int)((wxRect const *)arg1)->GetRight();
7153 wxPyEndAllowThreads(__tstate);
7154 if (PyErr_Occurred()) SWIG_fail;
7155 }
7156 resultobj = SWIG_From_int(static_cast< int >(result));
7157 return resultobj;
7158 fail:
7159 return NULL;
7160 }
7161
7162
7163 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7164 PyObject *resultobj = 0;
7165 wxRect *arg1 = (wxRect *) 0 ;
7166 int arg2 ;
7167 void *argp1 = 0 ;
7168 int res1 = 0 ;
7169 int val2 ;
7170 int ecode2 = 0 ;
7171 PyObject * obj0 = 0 ;
7172 PyObject * obj1 = 0 ;
7173 char * kwnames[] = {
7174 (char *) "self",(char *) "left", NULL
7175 };
7176
7177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",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_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7181 }
7182 arg1 = reinterpret_cast< wxRect * >(argp1);
7183 ecode2 = SWIG_AsVal_int(obj1, &val2);
7184 if (!SWIG_IsOK(ecode2)) {
7185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7186 }
7187 arg2 = static_cast< int >(val2);
7188 {
7189 PyThreadState* __tstate = wxPyBeginAllowThreads();
7190 (arg1)->SetLeft(arg2);
7191 wxPyEndAllowThreads(__tstate);
7192 if (PyErr_Occurred()) SWIG_fail;
7193 }
7194 resultobj = SWIG_Py_Void();
7195 return resultobj;
7196 fail:
7197 return NULL;
7198 }
7199
7200
7201 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7202 PyObject *resultobj = 0;
7203 wxRect *arg1 = (wxRect *) 0 ;
7204 int arg2 ;
7205 void *argp1 = 0 ;
7206 int res1 = 0 ;
7207 int val2 ;
7208 int ecode2 = 0 ;
7209 PyObject * obj0 = 0 ;
7210 PyObject * obj1 = 0 ;
7211 char * kwnames[] = {
7212 (char *) "self",(char *) "right", NULL
7213 };
7214
7215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7217 if (!SWIG_IsOK(res1)) {
7218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7219 }
7220 arg1 = reinterpret_cast< wxRect * >(argp1);
7221 ecode2 = SWIG_AsVal_int(obj1, &val2);
7222 if (!SWIG_IsOK(ecode2)) {
7223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7224 }
7225 arg2 = static_cast< int >(val2);
7226 {
7227 PyThreadState* __tstate = wxPyBeginAllowThreads();
7228 (arg1)->SetRight(arg2);
7229 wxPyEndAllowThreads(__tstate);
7230 if (PyErr_Occurred()) SWIG_fail;
7231 }
7232 resultobj = SWIG_Py_Void();
7233 return resultobj;
7234 fail:
7235 return NULL;
7236 }
7237
7238
7239 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7240 PyObject *resultobj = 0;
7241 wxRect *arg1 = (wxRect *) 0 ;
7242 int arg2 ;
7243 void *argp1 = 0 ;
7244 int res1 = 0 ;
7245 int val2 ;
7246 int ecode2 = 0 ;
7247 PyObject * obj0 = 0 ;
7248 PyObject * obj1 = 0 ;
7249 char * kwnames[] = {
7250 (char *) "self",(char *) "top", NULL
7251 };
7252
7253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7255 if (!SWIG_IsOK(res1)) {
7256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7257 }
7258 arg1 = reinterpret_cast< wxRect * >(argp1);
7259 ecode2 = SWIG_AsVal_int(obj1, &val2);
7260 if (!SWIG_IsOK(ecode2)) {
7261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7262 }
7263 arg2 = static_cast< int >(val2);
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 (arg1)->SetTop(arg2);
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 resultobj = SWIG_Py_Void();
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj = 0;
7279 wxRect *arg1 = (wxRect *) 0 ;
7280 int arg2 ;
7281 void *argp1 = 0 ;
7282 int res1 = 0 ;
7283 int val2 ;
7284 int ecode2 = 0 ;
7285 PyObject * obj0 = 0 ;
7286 PyObject * obj1 = 0 ;
7287 char * kwnames[] = {
7288 (char *) "self",(char *) "bottom", NULL
7289 };
7290
7291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7295 }
7296 arg1 = reinterpret_cast< wxRect * >(argp1);
7297 ecode2 = SWIG_AsVal_int(obj1, &val2);
7298 if (!SWIG_IsOK(ecode2)) {
7299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7300 }
7301 arg2 = static_cast< int >(val2);
7302 {
7303 PyThreadState* __tstate = wxPyBeginAllowThreads();
7304 (arg1)->SetBottom(arg2);
7305 wxPyEndAllowThreads(__tstate);
7306 if (PyErr_Occurred()) SWIG_fail;
7307 }
7308 resultobj = SWIG_Py_Void();
7309 return resultobj;
7310 fail:
7311 return NULL;
7312 }
7313
7314
7315 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7316 PyObject *resultobj = 0;
7317 wxRect *arg1 = (wxRect *) 0 ;
7318 int arg2 ;
7319 int arg3 ;
7320 wxRect *result = 0 ;
7321 void *argp1 = 0 ;
7322 int res1 = 0 ;
7323 int val2 ;
7324 int ecode2 = 0 ;
7325 int val3 ;
7326 int ecode3 = 0 ;
7327 PyObject * obj0 = 0 ;
7328 PyObject * obj1 = 0 ;
7329 PyObject * obj2 = 0 ;
7330 char * kwnames[] = {
7331 (char *) "self",(char *) "dx",(char *) "dy", NULL
7332 };
7333
7334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7336 if (!SWIG_IsOK(res1)) {
7337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7338 }
7339 arg1 = reinterpret_cast< wxRect * >(argp1);
7340 ecode2 = SWIG_AsVal_int(obj1, &val2);
7341 if (!SWIG_IsOK(ecode2)) {
7342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7343 }
7344 arg2 = static_cast< int >(val2);
7345 ecode3 = SWIG_AsVal_int(obj2, &val3);
7346 if (!SWIG_IsOK(ecode3)) {
7347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7348 }
7349 arg3 = static_cast< int >(val3);
7350 {
7351 PyThreadState* __tstate = wxPyBeginAllowThreads();
7352 {
7353 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7354 result = (wxRect *) &_result_ref;
7355 }
7356 wxPyEndAllowThreads(__tstate);
7357 if (PyErr_Occurred()) SWIG_fail;
7358 }
7359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7360 return resultobj;
7361 fail:
7362 return NULL;
7363 }
7364
7365
7366 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7367 PyObject *resultobj = 0;
7368 wxRect *arg1 = (wxRect *) 0 ;
7369 int arg2 ;
7370 int arg3 ;
7371 wxRect *result = 0 ;
7372 void *argp1 = 0 ;
7373 int res1 = 0 ;
7374 int val2 ;
7375 int ecode2 = 0 ;
7376 int val3 ;
7377 int ecode3 = 0 ;
7378 PyObject * obj0 = 0 ;
7379 PyObject * obj1 = 0 ;
7380 PyObject * obj2 = 0 ;
7381 char * kwnames[] = {
7382 (char *) "self",(char *) "dx",(char *) "dy", NULL
7383 };
7384
7385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7387 if (!SWIG_IsOK(res1)) {
7388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7389 }
7390 arg1 = reinterpret_cast< wxRect * >(argp1);
7391 ecode2 = SWIG_AsVal_int(obj1, &val2);
7392 if (!SWIG_IsOK(ecode2)) {
7393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7394 }
7395 arg2 = static_cast< int >(val2);
7396 ecode3 = SWIG_AsVal_int(obj2, &val3);
7397 if (!SWIG_IsOK(ecode3)) {
7398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7399 }
7400 arg3 = static_cast< int >(val3);
7401 {
7402 PyThreadState* __tstate = wxPyBeginAllowThreads();
7403 {
7404 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7405 result = (wxRect *) &_result_ref;
7406 }
7407 wxPyEndAllowThreads(__tstate);
7408 if (PyErr_Occurred()) SWIG_fail;
7409 }
7410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7411 return resultobj;
7412 fail:
7413 return NULL;
7414 }
7415
7416
7417 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7418 PyObject *resultobj = 0;
7419 wxRect *arg1 = (wxRect *) 0 ;
7420 int arg2 ;
7421 int arg3 ;
7422 void *argp1 = 0 ;
7423 int res1 = 0 ;
7424 int val2 ;
7425 int ecode2 = 0 ;
7426 int val3 ;
7427 int ecode3 = 0 ;
7428 PyObject * obj0 = 0 ;
7429 PyObject * obj1 = 0 ;
7430 PyObject * obj2 = 0 ;
7431 char * kwnames[] = {
7432 (char *) "self",(char *) "dx",(char *) "dy", NULL
7433 };
7434
7435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7437 if (!SWIG_IsOK(res1)) {
7438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7439 }
7440 arg1 = reinterpret_cast< wxRect * >(argp1);
7441 ecode2 = SWIG_AsVal_int(obj1, &val2);
7442 if (!SWIG_IsOK(ecode2)) {
7443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7444 }
7445 arg2 = static_cast< int >(val2);
7446 ecode3 = SWIG_AsVal_int(obj2, &val3);
7447 if (!SWIG_IsOK(ecode3)) {
7448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7449 }
7450 arg3 = static_cast< int >(val3);
7451 {
7452 PyThreadState* __tstate = wxPyBeginAllowThreads();
7453 (arg1)->Offset(arg2,arg3);
7454 wxPyEndAllowThreads(__tstate);
7455 if (PyErr_Occurred()) SWIG_fail;
7456 }
7457 resultobj = SWIG_Py_Void();
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7465 PyObject *resultobj = 0;
7466 wxRect *arg1 = (wxRect *) 0 ;
7467 wxPoint *arg2 = 0 ;
7468 void *argp1 = 0 ;
7469 int res1 = 0 ;
7470 wxPoint temp2 ;
7471 PyObject * obj0 = 0 ;
7472 PyObject * obj1 = 0 ;
7473 char * kwnames[] = {
7474 (char *) "self",(char *) "pt", NULL
7475 };
7476
7477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7479 if (!SWIG_IsOK(res1)) {
7480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7481 }
7482 arg1 = reinterpret_cast< wxRect * >(argp1);
7483 {
7484 arg2 = &temp2;
7485 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7486 }
7487 {
7488 PyThreadState* __tstate = wxPyBeginAllowThreads();
7489 (arg1)->Offset((wxPoint const &)*arg2);
7490 wxPyEndAllowThreads(__tstate);
7491 if (PyErr_Occurred()) SWIG_fail;
7492 }
7493 resultobj = SWIG_Py_Void();
7494 return resultobj;
7495 fail:
7496 return NULL;
7497 }
7498
7499
7500 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7501 PyObject *resultobj = 0;
7502 wxRect *arg1 = (wxRect *) 0 ;
7503 wxRect *arg2 = 0 ;
7504 wxRect result;
7505 void *argp1 = 0 ;
7506 int res1 = 0 ;
7507 wxRect temp2 ;
7508 PyObject * obj0 = 0 ;
7509 PyObject * obj1 = 0 ;
7510 char * kwnames[] = {
7511 (char *) "self",(char *) "rect", NULL
7512 };
7513
7514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7516 if (!SWIG_IsOK(res1)) {
7517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7518 }
7519 arg1 = reinterpret_cast< wxRect * >(argp1);
7520 {
7521 arg2 = &temp2;
7522 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7523 }
7524 {
7525 PyThreadState* __tstate = wxPyBeginAllowThreads();
7526 result = (arg1)->Intersect((wxRect const &)*arg2);
7527 wxPyEndAllowThreads(__tstate);
7528 if (PyErr_Occurred()) SWIG_fail;
7529 }
7530 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7531 return resultobj;
7532 fail:
7533 return NULL;
7534 }
7535
7536
7537 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7538 PyObject *resultobj = 0;
7539 wxRect *arg1 = (wxRect *) 0 ;
7540 wxRect *arg2 = 0 ;
7541 wxRect result;
7542 void *argp1 = 0 ;
7543 int res1 = 0 ;
7544 wxRect temp2 ;
7545 PyObject * obj0 = 0 ;
7546 PyObject * obj1 = 0 ;
7547 char * kwnames[] = {
7548 (char *) "self",(char *) "rect", NULL
7549 };
7550
7551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7553 if (!SWIG_IsOK(res1)) {
7554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7555 }
7556 arg1 = reinterpret_cast< wxRect * >(argp1);
7557 {
7558 arg2 = &temp2;
7559 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7560 }
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 result = (arg1)->Union((wxRect const &)*arg2);
7564 wxPyEndAllowThreads(__tstate);
7565 if (PyErr_Occurred()) SWIG_fail;
7566 }
7567 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7568 return resultobj;
7569 fail:
7570 return NULL;
7571 }
7572
7573
7574 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7575 PyObject *resultobj = 0;
7576 wxRect *arg1 = (wxRect *) 0 ;
7577 wxRect *arg2 = 0 ;
7578 wxRect result;
7579 void *argp1 = 0 ;
7580 int res1 = 0 ;
7581 wxRect temp2 ;
7582 PyObject * obj0 = 0 ;
7583 PyObject * obj1 = 0 ;
7584 char * kwnames[] = {
7585 (char *) "self",(char *) "rect", NULL
7586 };
7587
7588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7590 if (!SWIG_IsOK(res1)) {
7591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7592 }
7593 arg1 = reinterpret_cast< wxRect * >(argp1);
7594 {
7595 arg2 = &temp2;
7596 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7597 }
7598 {
7599 PyThreadState* __tstate = wxPyBeginAllowThreads();
7600 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7601 wxPyEndAllowThreads(__tstate);
7602 if (PyErr_Occurred()) SWIG_fail;
7603 }
7604 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7605 return resultobj;
7606 fail:
7607 return NULL;
7608 }
7609
7610
7611 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7612 PyObject *resultobj = 0;
7613 wxRect *arg1 = (wxRect *) 0 ;
7614 wxRect *arg2 = 0 ;
7615 wxRect *result = 0 ;
7616 void *argp1 = 0 ;
7617 int res1 = 0 ;
7618 wxRect temp2 ;
7619 PyObject * obj0 = 0 ;
7620 PyObject * obj1 = 0 ;
7621 char * kwnames[] = {
7622 (char *) "self",(char *) "rect", NULL
7623 };
7624
7625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7627 if (!SWIG_IsOK(res1)) {
7628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7629 }
7630 arg1 = reinterpret_cast< wxRect * >(argp1);
7631 {
7632 arg2 = &temp2;
7633 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7634 }
7635 {
7636 PyThreadState* __tstate = wxPyBeginAllowThreads();
7637 {
7638 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7639 result = (wxRect *) &_result_ref;
7640 }
7641 wxPyEndAllowThreads(__tstate);
7642 if (PyErr_Occurred()) SWIG_fail;
7643 }
7644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7645 return resultobj;
7646 fail:
7647 return NULL;
7648 }
7649
7650
7651 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7652 PyObject *resultobj = 0;
7653 wxRect *arg1 = (wxRect *) 0 ;
7654 PyObject *arg2 = (PyObject *) 0 ;
7655 bool result;
7656 void *argp1 = 0 ;
7657 int res1 = 0 ;
7658 PyObject * obj0 = 0 ;
7659 PyObject * obj1 = 0 ;
7660 char * kwnames[] = {
7661 (char *) "self",(char *) "other", NULL
7662 };
7663
7664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7666 if (!SWIG_IsOK(res1)) {
7667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7668 }
7669 arg1 = reinterpret_cast< wxRect * >(argp1);
7670 arg2 = obj1;
7671 {
7672 result = (bool)wxRect___eq__(arg1,arg2);
7673 if (PyErr_Occurred()) SWIG_fail;
7674 }
7675 {
7676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7677 }
7678 return resultobj;
7679 fail:
7680 return NULL;
7681 }
7682
7683
7684 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7685 PyObject *resultobj = 0;
7686 wxRect *arg1 = (wxRect *) 0 ;
7687 PyObject *arg2 = (PyObject *) 0 ;
7688 bool result;
7689 void *argp1 = 0 ;
7690 int res1 = 0 ;
7691 PyObject * obj0 = 0 ;
7692 PyObject * obj1 = 0 ;
7693 char * kwnames[] = {
7694 (char *) "self",(char *) "other", NULL
7695 };
7696
7697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7699 if (!SWIG_IsOK(res1)) {
7700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7701 }
7702 arg1 = reinterpret_cast< wxRect * >(argp1);
7703 arg2 = obj1;
7704 {
7705 result = (bool)wxRect___ne__(arg1,arg2);
7706 if (PyErr_Occurred()) SWIG_fail;
7707 }
7708 {
7709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7710 }
7711 return resultobj;
7712 fail:
7713 return NULL;
7714 }
7715
7716
7717 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7718 PyObject *resultobj = 0;
7719 wxRect *arg1 = (wxRect *) 0 ;
7720 int arg2 ;
7721 int arg3 ;
7722 bool result;
7723 void *argp1 = 0 ;
7724 int res1 = 0 ;
7725 int val2 ;
7726 int ecode2 = 0 ;
7727 int val3 ;
7728 int ecode3 = 0 ;
7729 PyObject * obj0 = 0 ;
7730 PyObject * obj1 = 0 ;
7731 PyObject * obj2 = 0 ;
7732 char * kwnames[] = {
7733 (char *) "self",(char *) "x",(char *) "y", NULL
7734 };
7735
7736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7738 if (!SWIG_IsOK(res1)) {
7739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7740 }
7741 arg1 = reinterpret_cast< wxRect * >(argp1);
7742 ecode2 = SWIG_AsVal_int(obj1, &val2);
7743 if (!SWIG_IsOK(ecode2)) {
7744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7745 }
7746 arg2 = static_cast< int >(val2);
7747 ecode3 = SWIG_AsVal_int(obj2, &val3);
7748 if (!SWIG_IsOK(ecode3)) {
7749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7750 }
7751 arg3 = static_cast< int >(val3);
7752 {
7753 PyThreadState* __tstate = wxPyBeginAllowThreads();
7754 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7755 wxPyEndAllowThreads(__tstate);
7756 if (PyErr_Occurred()) SWIG_fail;
7757 }
7758 {
7759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7760 }
7761 return resultobj;
7762 fail:
7763 return NULL;
7764 }
7765
7766
7767 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7768 PyObject *resultobj = 0;
7769 wxRect *arg1 = (wxRect *) 0 ;
7770 wxPoint *arg2 = 0 ;
7771 bool result;
7772 void *argp1 = 0 ;
7773 int res1 = 0 ;
7774 wxPoint temp2 ;
7775 PyObject * obj0 = 0 ;
7776 PyObject * obj1 = 0 ;
7777 char * kwnames[] = {
7778 (char *) "self",(char *) "pt", NULL
7779 };
7780
7781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7783 if (!SWIG_IsOK(res1)) {
7784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7785 }
7786 arg1 = reinterpret_cast< wxRect * >(argp1);
7787 {
7788 arg2 = &temp2;
7789 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7790 }
7791 {
7792 PyThreadState* __tstate = wxPyBeginAllowThreads();
7793 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7794 wxPyEndAllowThreads(__tstate);
7795 if (PyErr_Occurred()) SWIG_fail;
7796 }
7797 {
7798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7799 }
7800 return resultobj;
7801 fail:
7802 return NULL;
7803 }
7804
7805
7806 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7807 PyObject *resultobj = 0;
7808 wxRect *arg1 = (wxRect *) 0 ;
7809 wxRect *arg2 = 0 ;
7810 bool result;
7811 void *argp1 = 0 ;
7812 int res1 = 0 ;
7813 wxRect temp2 ;
7814 PyObject * obj0 = 0 ;
7815 PyObject * obj1 = 0 ;
7816 char * kwnames[] = {
7817 (char *) "self",(char *) "rect", NULL
7818 };
7819
7820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7822 if (!SWIG_IsOK(res1)) {
7823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7824 }
7825 arg1 = reinterpret_cast< wxRect * >(argp1);
7826 {
7827 arg2 = &temp2;
7828 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7829 }
7830 {
7831 PyThreadState* __tstate = wxPyBeginAllowThreads();
7832 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7833 wxPyEndAllowThreads(__tstate);
7834 if (PyErr_Occurred()) SWIG_fail;
7835 }
7836 {
7837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7838 }
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7846 PyObject *resultobj = 0;
7847 wxRect *arg1 = (wxRect *) 0 ;
7848 wxRect *arg2 = 0 ;
7849 bool result;
7850 void *argp1 = 0 ;
7851 int res1 = 0 ;
7852 wxRect temp2 ;
7853 PyObject * obj0 = 0 ;
7854 PyObject * obj1 = 0 ;
7855 char * kwnames[] = {
7856 (char *) "self",(char *) "rect", NULL
7857 };
7858
7859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7861 if (!SWIG_IsOK(res1)) {
7862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7863 }
7864 arg1 = reinterpret_cast< wxRect * >(argp1);
7865 {
7866 arg2 = &temp2;
7867 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7868 }
7869 {
7870 PyThreadState* __tstate = wxPyBeginAllowThreads();
7871 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7872 wxPyEndAllowThreads(__tstate);
7873 if (PyErr_Occurred()) SWIG_fail;
7874 }
7875 {
7876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7877 }
7878 return resultobj;
7879 fail:
7880 return NULL;
7881 }
7882
7883
7884 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7885 PyObject *resultobj = 0;
7886 wxRect *arg1 = (wxRect *) 0 ;
7887 wxRect *arg2 = 0 ;
7888 int arg3 = (int) wxBOTH ;
7889 wxRect result;
7890 void *argp1 = 0 ;
7891 int res1 = 0 ;
7892 wxRect temp2 ;
7893 int val3 ;
7894 int ecode3 = 0 ;
7895 PyObject * obj0 = 0 ;
7896 PyObject * obj1 = 0 ;
7897 PyObject * obj2 = 0 ;
7898 char * kwnames[] = {
7899 (char *) "self",(char *) "r",(char *) "dir", NULL
7900 };
7901
7902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7904 if (!SWIG_IsOK(res1)) {
7905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7906 }
7907 arg1 = reinterpret_cast< wxRect * >(argp1);
7908 {
7909 arg2 = &temp2;
7910 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7911 }
7912 if (obj2) {
7913 ecode3 = SWIG_AsVal_int(obj2, &val3);
7914 if (!SWIG_IsOK(ecode3)) {
7915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7916 }
7917 arg3 = static_cast< int >(val3);
7918 }
7919 {
7920 PyThreadState* __tstate = wxPyBeginAllowThreads();
7921 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7922 wxPyEndAllowThreads(__tstate);
7923 if (PyErr_Occurred()) SWIG_fail;
7924 }
7925 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7926 return resultobj;
7927 fail:
7928 return NULL;
7929 }
7930
7931
7932 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7933 PyObject *resultobj = 0;
7934 wxRect *arg1 = (wxRect *) 0 ;
7935 int arg2 ;
7936 void *argp1 = 0 ;
7937 int res1 = 0 ;
7938 int val2 ;
7939 int ecode2 = 0 ;
7940 PyObject *swig_obj[2] ;
7941
7942 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7944 if (!SWIG_IsOK(res1)) {
7945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7946 }
7947 arg1 = reinterpret_cast< wxRect * >(argp1);
7948 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7949 if (!SWIG_IsOK(ecode2)) {
7950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7951 }
7952 arg2 = static_cast< int >(val2);
7953 if (arg1) (arg1)->x = arg2;
7954
7955 resultobj = SWIG_Py_Void();
7956 return resultobj;
7957 fail:
7958 return NULL;
7959 }
7960
7961
7962 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7963 PyObject *resultobj = 0;
7964 wxRect *arg1 = (wxRect *) 0 ;
7965 int result;
7966 void *argp1 = 0 ;
7967 int res1 = 0 ;
7968 PyObject *swig_obj[1] ;
7969
7970 if (!args) SWIG_fail;
7971 swig_obj[0] = args;
7972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7973 if (!SWIG_IsOK(res1)) {
7974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7975 }
7976 arg1 = reinterpret_cast< wxRect * >(argp1);
7977 result = (int) ((arg1)->x);
7978 resultobj = SWIG_From_int(static_cast< int >(result));
7979 return resultobj;
7980 fail:
7981 return NULL;
7982 }
7983
7984
7985 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7986 PyObject *resultobj = 0;
7987 wxRect *arg1 = (wxRect *) 0 ;
7988 int arg2 ;
7989 void *argp1 = 0 ;
7990 int res1 = 0 ;
7991 int val2 ;
7992 int ecode2 = 0 ;
7993 PyObject *swig_obj[2] ;
7994
7995 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7997 if (!SWIG_IsOK(res1)) {
7998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7999 }
8000 arg1 = reinterpret_cast< wxRect * >(argp1);
8001 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8002 if (!SWIG_IsOK(ecode2)) {
8003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8004 }
8005 arg2 = static_cast< int >(val2);
8006 if (arg1) (arg1)->y = arg2;
8007
8008 resultobj = SWIG_Py_Void();
8009 return resultobj;
8010 fail:
8011 return NULL;
8012 }
8013
8014
8015 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8016 PyObject *resultobj = 0;
8017 wxRect *arg1 = (wxRect *) 0 ;
8018 int result;
8019 void *argp1 = 0 ;
8020 int res1 = 0 ;
8021 PyObject *swig_obj[1] ;
8022
8023 if (!args) SWIG_fail;
8024 swig_obj[0] = args;
8025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8026 if (!SWIG_IsOK(res1)) {
8027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8028 }
8029 arg1 = reinterpret_cast< wxRect * >(argp1);
8030 result = (int) ((arg1)->y);
8031 resultobj = SWIG_From_int(static_cast< int >(result));
8032 return resultobj;
8033 fail:
8034 return NULL;
8035 }
8036
8037
8038 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8039 PyObject *resultobj = 0;
8040 wxRect *arg1 = (wxRect *) 0 ;
8041 int arg2 ;
8042 void *argp1 = 0 ;
8043 int res1 = 0 ;
8044 int val2 ;
8045 int ecode2 = 0 ;
8046 PyObject *swig_obj[2] ;
8047
8048 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8050 if (!SWIG_IsOK(res1)) {
8051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8052 }
8053 arg1 = reinterpret_cast< wxRect * >(argp1);
8054 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8055 if (!SWIG_IsOK(ecode2)) {
8056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8057 }
8058 arg2 = static_cast< int >(val2);
8059 if (arg1) (arg1)->width = arg2;
8060
8061 resultobj = SWIG_Py_Void();
8062 return resultobj;
8063 fail:
8064 return NULL;
8065 }
8066
8067
8068 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8069 PyObject *resultobj = 0;
8070 wxRect *arg1 = (wxRect *) 0 ;
8071 int result;
8072 void *argp1 = 0 ;
8073 int res1 = 0 ;
8074 PyObject *swig_obj[1] ;
8075
8076 if (!args) SWIG_fail;
8077 swig_obj[0] = args;
8078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8079 if (!SWIG_IsOK(res1)) {
8080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8081 }
8082 arg1 = reinterpret_cast< wxRect * >(argp1);
8083 result = (int) ((arg1)->width);
8084 resultobj = SWIG_From_int(static_cast< int >(result));
8085 return resultobj;
8086 fail:
8087 return NULL;
8088 }
8089
8090
8091 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8092 PyObject *resultobj = 0;
8093 wxRect *arg1 = (wxRect *) 0 ;
8094 int arg2 ;
8095 void *argp1 = 0 ;
8096 int res1 = 0 ;
8097 int val2 ;
8098 int ecode2 = 0 ;
8099 PyObject *swig_obj[2] ;
8100
8101 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8103 if (!SWIG_IsOK(res1)) {
8104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8105 }
8106 arg1 = reinterpret_cast< wxRect * >(argp1);
8107 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8108 if (!SWIG_IsOK(ecode2)) {
8109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8110 }
8111 arg2 = static_cast< int >(val2);
8112 if (arg1) (arg1)->height = arg2;
8113
8114 resultobj = SWIG_Py_Void();
8115 return resultobj;
8116 fail:
8117 return NULL;
8118 }
8119
8120
8121 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8122 PyObject *resultobj = 0;
8123 wxRect *arg1 = (wxRect *) 0 ;
8124 int result;
8125 void *argp1 = 0 ;
8126 int res1 = 0 ;
8127 PyObject *swig_obj[1] ;
8128
8129 if (!args) SWIG_fail;
8130 swig_obj[0] = args;
8131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8132 if (!SWIG_IsOK(res1)) {
8133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8134 }
8135 arg1 = reinterpret_cast< wxRect * >(argp1);
8136 result = (int) ((arg1)->height);
8137 resultobj = SWIG_From_int(static_cast< int >(result));
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8145 PyObject *resultobj = 0;
8146 wxRect *arg1 = (wxRect *) 0 ;
8147 int arg2 = (int) 0 ;
8148 int arg3 = (int) 0 ;
8149 int arg4 = (int) 0 ;
8150 int arg5 = (int) 0 ;
8151 void *argp1 = 0 ;
8152 int res1 = 0 ;
8153 int val2 ;
8154 int ecode2 = 0 ;
8155 int val3 ;
8156 int ecode3 = 0 ;
8157 int val4 ;
8158 int ecode4 = 0 ;
8159 int val5 ;
8160 int ecode5 = 0 ;
8161 PyObject * obj0 = 0 ;
8162 PyObject * obj1 = 0 ;
8163 PyObject * obj2 = 0 ;
8164 PyObject * obj3 = 0 ;
8165 PyObject * obj4 = 0 ;
8166 char * kwnames[] = {
8167 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8168 };
8169
8170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8172 if (!SWIG_IsOK(res1)) {
8173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8174 }
8175 arg1 = reinterpret_cast< wxRect * >(argp1);
8176 if (obj1) {
8177 ecode2 = SWIG_AsVal_int(obj1, &val2);
8178 if (!SWIG_IsOK(ecode2)) {
8179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8180 }
8181 arg2 = static_cast< int >(val2);
8182 }
8183 if (obj2) {
8184 ecode3 = SWIG_AsVal_int(obj2, &val3);
8185 if (!SWIG_IsOK(ecode3)) {
8186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8187 }
8188 arg3 = static_cast< int >(val3);
8189 }
8190 if (obj3) {
8191 ecode4 = SWIG_AsVal_int(obj3, &val4);
8192 if (!SWIG_IsOK(ecode4)) {
8193 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8194 }
8195 arg4 = static_cast< int >(val4);
8196 }
8197 if (obj4) {
8198 ecode5 = SWIG_AsVal_int(obj4, &val5);
8199 if (!SWIG_IsOK(ecode5)) {
8200 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8201 }
8202 arg5 = static_cast< int >(val5);
8203 }
8204 {
8205 PyThreadState* __tstate = wxPyBeginAllowThreads();
8206 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8207 wxPyEndAllowThreads(__tstate);
8208 if (PyErr_Occurred()) SWIG_fail;
8209 }
8210 resultobj = SWIG_Py_Void();
8211 return resultobj;
8212 fail:
8213 return NULL;
8214 }
8215
8216
8217 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8218 PyObject *resultobj = 0;
8219 wxRect *arg1 = (wxRect *) 0 ;
8220 PyObject *result = 0 ;
8221 void *argp1 = 0 ;
8222 int res1 = 0 ;
8223 PyObject *swig_obj[1] ;
8224
8225 if (!args) SWIG_fail;
8226 swig_obj[0] = args;
8227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8228 if (!SWIG_IsOK(res1)) {
8229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8230 }
8231 arg1 = reinterpret_cast< wxRect * >(argp1);
8232 {
8233 PyThreadState* __tstate = wxPyBeginAllowThreads();
8234 result = (PyObject *)wxRect_Get(arg1);
8235 wxPyEndAllowThreads(__tstate);
8236 if (PyErr_Occurred()) SWIG_fail;
8237 }
8238 resultobj = result;
8239 return resultobj;
8240 fail:
8241 return NULL;
8242 }
8243
8244
8245 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8246 PyObject *obj;
8247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8248 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8249 return SWIG_Py_Void();
8250 }
8251
8252 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8253 return SWIG_Python_InitShadowInstance(args);
8254 }
8255
8256 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8257 PyObject *resultobj = 0;
8258 wxRect *arg1 = (wxRect *) 0 ;
8259 wxRect *arg2 = (wxRect *) 0 ;
8260 PyObject *result = 0 ;
8261 void *argp1 = 0 ;
8262 int res1 = 0 ;
8263 void *argp2 = 0 ;
8264 int res2 = 0 ;
8265 PyObject * obj0 = 0 ;
8266 PyObject * obj1 = 0 ;
8267 char * kwnames[] = {
8268 (char *) "r1",(char *) "r2", NULL
8269 };
8270
8271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8273 if (!SWIG_IsOK(res1)) {
8274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8275 }
8276 arg1 = reinterpret_cast< wxRect * >(argp1);
8277 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8278 if (!SWIG_IsOK(res2)) {
8279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8280 }
8281 arg2 = reinterpret_cast< wxRect * >(argp2);
8282 {
8283 if (!wxPyCheckForApp()) SWIG_fail;
8284 PyThreadState* __tstate = wxPyBeginAllowThreads();
8285 result = (PyObject *)wxIntersectRect(arg1,arg2);
8286 wxPyEndAllowThreads(__tstate);
8287 if (PyErr_Occurred()) SWIG_fail;
8288 }
8289 resultobj = result;
8290 return resultobj;
8291 fail:
8292 return NULL;
8293 }
8294
8295
8296 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8297 PyObject *resultobj = 0;
8298 double arg1 = (double) 0.0 ;
8299 double arg2 = (double) 0.0 ;
8300 wxPoint2D *result = 0 ;
8301 double val1 ;
8302 int ecode1 = 0 ;
8303 double val2 ;
8304 int ecode2 = 0 ;
8305 PyObject * obj0 = 0 ;
8306 PyObject * obj1 = 0 ;
8307 char * kwnames[] = {
8308 (char *) "x",(char *) "y", NULL
8309 };
8310
8311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8312 if (obj0) {
8313 ecode1 = SWIG_AsVal_double(obj0, &val1);
8314 if (!SWIG_IsOK(ecode1)) {
8315 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8316 }
8317 arg1 = static_cast< double >(val1);
8318 }
8319 if (obj1) {
8320 ecode2 = SWIG_AsVal_double(obj1, &val2);
8321 if (!SWIG_IsOK(ecode2)) {
8322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8323 }
8324 arg2 = static_cast< double >(val2);
8325 }
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8329 wxPyEndAllowThreads(__tstate);
8330 if (PyErr_Occurred()) SWIG_fail;
8331 }
8332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8333 return resultobj;
8334 fail:
8335 return NULL;
8336 }
8337
8338
8339 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj = 0;
8341 wxPoint2D *arg1 = 0 ;
8342 wxPoint2D *result = 0 ;
8343 wxPoint2D temp1 ;
8344 PyObject * obj0 = 0 ;
8345 char * kwnames[] = {
8346 (char *) "pt", NULL
8347 };
8348
8349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8350 {
8351 arg1 = &temp1;
8352 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8353 }
8354 {
8355 PyThreadState* __tstate = wxPyBeginAllowThreads();
8356 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8357 wxPyEndAllowThreads(__tstate);
8358 if (PyErr_Occurred()) SWIG_fail;
8359 }
8360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8361 return resultobj;
8362 fail:
8363 return NULL;
8364 }
8365
8366
8367 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8368 PyObject *resultobj = 0;
8369 wxPoint *arg1 = 0 ;
8370 wxPoint2D *result = 0 ;
8371 wxPoint temp1 ;
8372 PyObject * obj0 = 0 ;
8373 char * kwnames[] = {
8374 (char *) "pt", NULL
8375 };
8376
8377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8378 {
8379 arg1 = &temp1;
8380 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8381 }
8382 {
8383 PyThreadState* __tstate = wxPyBeginAllowThreads();
8384 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8385 wxPyEndAllowThreads(__tstate);
8386 if (PyErr_Occurred()) SWIG_fail;
8387 }
8388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8389 return resultobj;
8390 fail:
8391 return NULL;
8392 }
8393
8394
8395 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8396 PyObject *resultobj = 0;
8397 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8398 void *argp1 = 0 ;
8399 int res1 = 0 ;
8400 PyObject *swig_obj[1] ;
8401
8402 if (!args) SWIG_fail;
8403 swig_obj[0] = args;
8404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8405 if (!SWIG_IsOK(res1)) {
8406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8407 }
8408 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8409 {
8410 PyThreadState* __tstate = wxPyBeginAllowThreads();
8411 delete arg1;
8412
8413 wxPyEndAllowThreads(__tstate);
8414 if (PyErr_Occurred()) SWIG_fail;
8415 }
8416 resultobj = SWIG_Py_Void();
8417 return resultobj;
8418 fail:
8419 return NULL;
8420 }
8421
8422
8423 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8424 PyObject *resultobj = 0;
8425 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8426 int *arg2 = (int *) 0 ;
8427 int *arg3 = (int *) 0 ;
8428 void *argp1 = 0 ;
8429 int res1 = 0 ;
8430 int temp2 ;
8431 int res2 = SWIG_TMPOBJ ;
8432 int temp3 ;
8433 int res3 = SWIG_TMPOBJ ;
8434 PyObject *swig_obj[1] ;
8435
8436 arg2 = &temp2;
8437 arg3 = &temp3;
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_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8443 }
8444 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8445 {
8446 PyThreadState* __tstate = wxPyBeginAllowThreads();
8447 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8448 wxPyEndAllowThreads(__tstate);
8449 if (PyErr_Occurred()) SWIG_fail;
8450 }
8451 resultobj = SWIG_Py_Void();
8452 if (SWIG_IsTmpObj(res2)) {
8453 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8454 } else {
8455 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8456 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8457 }
8458 if (SWIG_IsTmpObj(res3)) {
8459 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8460 } else {
8461 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8462 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8463 }
8464 return resultobj;
8465 fail:
8466 return NULL;
8467 }
8468
8469
8470 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8471 PyObject *resultobj = 0;
8472 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8473 int *arg2 = (int *) 0 ;
8474 int *arg3 = (int *) 0 ;
8475 void *argp1 = 0 ;
8476 int res1 = 0 ;
8477 int temp2 ;
8478 int res2 = SWIG_TMPOBJ ;
8479 int temp3 ;
8480 int res3 = SWIG_TMPOBJ ;
8481 PyObject *swig_obj[1] ;
8482
8483 arg2 = &temp2;
8484 arg3 = &temp3;
8485 if (!args) SWIG_fail;
8486 swig_obj[0] = args;
8487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8488 if (!SWIG_IsOK(res1)) {
8489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8490 }
8491 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8492 {
8493 PyThreadState* __tstate = wxPyBeginAllowThreads();
8494 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8495 wxPyEndAllowThreads(__tstate);
8496 if (PyErr_Occurred()) SWIG_fail;
8497 }
8498 resultobj = SWIG_Py_Void();
8499 if (SWIG_IsTmpObj(res2)) {
8500 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8501 } else {
8502 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8503 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8504 }
8505 if (SWIG_IsTmpObj(res3)) {
8506 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8507 } else {
8508 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8510 }
8511 return resultobj;
8512 fail:
8513 return NULL;
8514 }
8515
8516
8517 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8518 PyObject *resultobj = 0;
8519 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8520 double result;
8521 void *argp1 = 0 ;
8522 int res1 = 0 ;
8523 PyObject *swig_obj[1] ;
8524
8525 if (!args) SWIG_fail;
8526 swig_obj[0] = args;
8527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8528 if (!SWIG_IsOK(res1)) {
8529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8530 }
8531 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8532 {
8533 PyThreadState* __tstate = wxPyBeginAllowThreads();
8534 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8535 wxPyEndAllowThreads(__tstate);
8536 if (PyErr_Occurred()) SWIG_fail;
8537 }
8538 resultobj = SWIG_From_double(static_cast< double >(result));
8539 return resultobj;
8540 fail:
8541 return NULL;
8542 }
8543
8544
8545 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8546 PyObject *resultobj = 0;
8547 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8548 double result;
8549 void *argp1 = 0 ;
8550 int res1 = 0 ;
8551 PyObject *swig_obj[1] ;
8552
8553 if (!args) SWIG_fail;
8554 swig_obj[0] = args;
8555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8556 if (!SWIG_IsOK(res1)) {
8557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8558 }
8559 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8563 wxPyEndAllowThreads(__tstate);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 resultobj = SWIG_From_double(static_cast< double >(result));
8567 return resultobj;
8568 fail:
8569 return NULL;
8570 }
8571
8572
8573 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8574 PyObject *resultobj = 0;
8575 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8576 double arg2 ;
8577 void *argp1 = 0 ;
8578 int res1 = 0 ;
8579 double val2 ;
8580 int ecode2 = 0 ;
8581 PyObject * obj0 = 0 ;
8582 PyObject * obj1 = 0 ;
8583 char * kwnames[] = {
8584 (char *) "self",(char *) "length", NULL
8585 };
8586
8587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8589 if (!SWIG_IsOK(res1)) {
8590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8591 }
8592 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8593 ecode2 = SWIG_AsVal_double(obj1, &val2);
8594 if (!SWIG_IsOK(ecode2)) {
8595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8596 }
8597 arg2 = static_cast< double >(val2);
8598 {
8599 PyThreadState* __tstate = wxPyBeginAllowThreads();
8600 (arg1)->SetVectorLength(arg2);
8601 wxPyEndAllowThreads(__tstate);
8602 if (PyErr_Occurred()) SWIG_fail;
8603 }
8604 resultobj = SWIG_Py_Void();
8605 return resultobj;
8606 fail:
8607 return NULL;
8608 }
8609
8610
8611 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8612 PyObject *resultobj = 0;
8613 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8614 double arg2 ;
8615 void *argp1 = 0 ;
8616 int res1 = 0 ;
8617 double val2 ;
8618 int ecode2 = 0 ;
8619 PyObject * obj0 = 0 ;
8620 PyObject * obj1 = 0 ;
8621 char * kwnames[] = {
8622 (char *) "self",(char *) "degrees", NULL
8623 };
8624
8625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8627 if (!SWIG_IsOK(res1)) {
8628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8629 }
8630 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8631 ecode2 = SWIG_AsVal_double(obj1, &val2);
8632 if (!SWIG_IsOK(ecode2)) {
8633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8634 }
8635 arg2 = static_cast< double >(val2);
8636 {
8637 PyThreadState* __tstate = wxPyBeginAllowThreads();
8638 (arg1)->SetVectorAngle(arg2);
8639 wxPyEndAllowThreads(__tstate);
8640 if (PyErr_Occurred()) SWIG_fail;
8641 }
8642 resultobj = SWIG_Py_Void();
8643 return resultobj;
8644 fail:
8645 return NULL;
8646 }
8647
8648
8649 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8650 PyObject *resultobj = 0;
8651 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8652 wxPoint2D *arg2 = 0 ;
8653 double result;
8654 void *argp1 = 0 ;
8655 int res1 = 0 ;
8656 wxPoint2D temp2 ;
8657 PyObject * obj0 = 0 ;
8658 PyObject * obj1 = 0 ;
8659 char * kwnames[] = {
8660 (char *) "self",(char *) "pt", NULL
8661 };
8662
8663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8665 if (!SWIG_IsOK(res1)) {
8666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8667 }
8668 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8669 {
8670 arg2 = &temp2;
8671 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8672 }
8673 {
8674 PyThreadState* __tstate = wxPyBeginAllowThreads();
8675 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8676 wxPyEndAllowThreads(__tstate);
8677 if (PyErr_Occurred()) SWIG_fail;
8678 }
8679 resultobj = SWIG_From_double(static_cast< double >(result));
8680 return resultobj;
8681 fail:
8682 return NULL;
8683 }
8684
8685
8686 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8687 PyObject *resultobj = 0;
8688 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8689 wxPoint2D *arg2 = 0 ;
8690 double result;
8691 void *argp1 = 0 ;
8692 int res1 = 0 ;
8693 wxPoint2D temp2 ;
8694 PyObject * obj0 = 0 ;
8695 PyObject * obj1 = 0 ;
8696 char * kwnames[] = {
8697 (char *) "self",(char *) "pt", NULL
8698 };
8699
8700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8702 if (!SWIG_IsOK(res1)) {
8703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8704 }
8705 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8706 {
8707 arg2 = &temp2;
8708 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8709 }
8710 {
8711 PyThreadState* __tstate = wxPyBeginAllowThreads();
8712 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8713 wxPyEndAllowThreads(__tstate);
8714 if (PyErr_Occurred()) SWIG_fail;
8715 }
8716 resultobj = SWIG_From_double(static_cast< double >(result));
8717 return resultobj;
8718 fail:
8719 return NULL;
8720 }
8721
8722
8723 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8724 PyObject *resultobj = 0;
8725 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8726 wxPoint2D *arg2 = 0 ;
8727 double result;
8728 void *argp1 = 0 ;
8729 int res1 = 0 ;
8730 wxPoint2D temp2 ;
8731 PyObject * obj0 = 0 ;
8732 PyObject * obj1 = 0 ;
8733 char * kwnames[] = {
8734 (char *) "self",(char *) "vec", NULL
8735 };
8736
8737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8739 if (!SWIG_IsOK(res1)) {
8740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8741 }
8742 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8743 {
8744 arg2 = &temp2;
8745 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8746 }
8747 {
8748 PyThreadState* __tstate = wxPyBeginAllowThreads();
8749 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8750 wxPyEndAllowThreads(__tstate);
8751 if (PyErr_Occurred()) SWIG_fail;
8752 }
8753 resultobj = SWIG_From_double(static_cast< double >(result));
8754 return resultobj;
8755 fail:
8756 return NULL;
8757 }
8758
8759
8760 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8761 PyObject *resultobj = 0;
8762 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8763 wxPoint2D *arg2 = 0 ;
8764 double result;
8765 void *argp1 = 0 ;
8766 int res1 = 0 ;
8767 wxPoint2D temp2 ;
8768 PyObject * obj0 = 0 ;
8769 PyObject * obj1 = 0 ;
8770 char * kwnames[] = {
8771 (char *) "self",(char *) "vec", NULL
8772 };
8773
8774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8776 if (!SWIG_IsOK(res1)) {
8777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8778 }
8779 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8780 {
8781 arg2 = &temp2;
8782 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8783 }
8784 {
8785 PyThreadState* __tstate = wxPyBeginAllowThreads();
8786 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8787 wxPyEndAllowThreads(__tstate);
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 resultobj = SWIG_From_double(static_cast< double >(result));
8791 return resultobj;
8792 fail:
8793 return NULL;
8794 }
8795
8796
8797 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8798 PyObject *resultobj = 0;
8799 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8800 wxPoint2D result;
8801 void *argp1 = 0 ;
8802 int res1 = 0 ;
8803 PyObject *swig_obj[1] ;
8804
8805 if (!args) SWIG_fail;
8806 swig_obj[0] = args;
8807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8808 if (!SWIG_IsOK(res1)) {
8809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8810 }
8811 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8812 {
8813 PyThreadState* __tstate = wxPyBeginAllowThreads();
8814 result = (arg1)->operator -();
8815 wxPyEndAllowThreads(__tstate);
8816 if (PyErr_Occurred()) SWIG_fail;
8817 }
8818 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8819 return resultobj;
8820 fail:
8821 return NULL;
8822 }
8823
8824
8825 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8826 PyObject *resultobj = 0;
8827 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8828 wxPoint2D *arg2 = 0 ;
8829 wxPoint2D *result = 0 ;
8830 void *argp1 = 0 ;
8831 int res1 = 0 ;
8832 wxPoint2D temp2 ;
8833 PyObject * obj0 = 0 ;
8834 PyObject * obj1 = 0 ;
8835 char * kwnames[] = {
8836 (char *) "self",(char *) "pt", NULL
8837 };
8838
8839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8841 if (!SWIG_IsOK(res1)) {
8842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8843 }
8844 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8845 {
8846 arg2 = &temp2;
8847 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8848 }
8849 {
8850 PyThreadState* __tstate = wxPyBeginAllowThreads();
8851 {
8852 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8853 result = (wxPoint2D *) &_result_ref;
8854 }
8855 wxPyEndAllowThreads(__tstate);
8856 if (PyErr_Occurred()) SWIG_fail;
8857 }
8858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8859 return resultobj;
8860 fail:
8861 return NULL;
8862 }
8863
8864
8865 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8866 PyObject *resultobj = 0;
8867 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8868 wxPoint2D *arg2 = 0 ;
8869 wxPoint2D *result = 0 ;
8870 void *argp1 = 0 ;
8871 int res1 = 0 ;
8872 wxPoint2D temp2 ;
8873 PyObject * obj0 = 0 ;
8874 PyObject * obj1 = 0 ;
8875 char * kwnames[] = {
8876 (char *) "self",(char *) "pt", NULL
8877 };
8878
8879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8881 if (!SWIG_IsOK(res1)) {
8882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8883 }
8884 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8885 {
8886 arg2 = &temp2;
8887 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8888 }
8889 {
8890 PyThreadState* __tstate = wxPyBeginAllowThreads();
8891 {
8892 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8893 result = (wxPoint2D *) &_result_ref;
8894 }
8895 wxPyEndAllowThreads(__tstate);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8899 return resultobj;
8900 fail:
8901 return NULL;
8902 }
8903
8904
8905 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8906 PyObject *resultobj = 0;
8907 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8908 wxPoint2D *arg2 = 0 ;
8909 wxPoint2D *result = 0 ;
8910 void *argp1 = 0 ;
8911 int res1 = 0 ;
8912 wxPoint2D temp2 ;
8913 PyObject * obj0 = 0 ;
8914 PyObject * obj1 = 0 ;
8915 char * kwnames[] = {
8916 (char *) "self",(char *) "pt", NULL
8917 };
8918
8919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8921 if (!SWIG_IsOK(res1)) {
8922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8923 }
8924 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8925 {
8926 arg2 = &temp2;
8927 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8928 }
8929 {
8930 PyThreadState* __tstate = wxPyBeginAllowThreads();
8931 {
8932 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8933 result = (wxPoint2D *) &_result_ref;
8934 }
8935 wxPyEndAllowThreads(__tstate);
8936 if (PyErr_Occurred()) SWIG_fail;
8937 }
8938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8939 return resultobj;
8940 fail:
8941 return NULL;
8942 }
8943
8944
8945 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8946 PyObject *resultobj = 0;
8947 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8948 wxPoint2D *arg2 = 0 ;
8949 wxPoint2D *result = 0 ;
8950 void *argp1 = 0 ;
8951 int res1 = 0 ;
8952 wxPoint2D temp2 ;
8953 PyObject * obj0 = 0 ;
8954 PyObject * obj1 = 0 ;
8955 char * kwnames[] = {
8956 (char *) "self",(char *) "pt", NULL
8957 };
8958
8959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8961 if (!SWIG_IsOK(res1)) {
8962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8963 }
8964 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8965 {
8966 arg2 = &temp2;
8967 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8968 }
8969 {
8970 PyThreadState* __tstate = wxPyBeginAllowThreads();
8971 {
8972 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8973 result = (wxPoint2D *) &_result_ref;
8974 }
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8986 PyObject *resultobj = 0;
8987 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8988 PyObject *arg2 = (PyObject *) 0 ;
8989 bool result;
8990 void *argp1 = 0 ;
8991 int res1 = 0 ;
8992 PyObject * obj0 = 0 ;
8993 PyObject * obj1 = 0 ;
8994 char * kwnames[] = {
8995 (char *) "self",(char *) "other", NULL
8996 };
8997
8998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9000 if (!SWIG_IsOK(res1)) {
9001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9002 }
9003 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9004 arg2 = obj1;
9005 {
9006 result = (bool)wxPoint2D___eq__(arg1,arg2);
9007 if (PyErr_Occurred()) SWIG_fail;
9008 }
9009 {
9010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9011 }
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9019 PyObject *resultobj = 0;
9020 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9021 PyObject *arg2 = (PyObject *) 0 ;
9022 bool result;
9023 void *argp1 = 0 ;
9024 int res1 = 0 ;
9025 PyObject * obj0 = 0 ;
9026 PyObject * obj1 = 0 ;
9027 char * kwnames[] = {
9028 (char *) "self",(char *) "other", NULL
9029 };
9030
9031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
9032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9033 if (!SWIG_IsOK(res1)) {
9034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9035 }
9036 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9037 arg2 = obj1;
9038 {
9039 result = (bool)wxPoint2D___ne__(arg1,arg2);
9040 if (PyErr_Occurred()) SWIG_fail;
9041 }
9042 {
9043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9044 }
9045 return resultobj;
9046 fail:
9047 return NULL;
9048 }
9049
9050
9051 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9052 PyObject *resultobj = 0;
9053 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9054 double arg2 ;
9055 void *argp1 = 0 ;
9056 int res1 = 0 ;
9057 double val2 ;
9058 int ecode2 = 0 ;
9059 PyObject *swig_obj[2] ;
9060
9061 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9063 if (!SWIG_IsOK(res1)) {
9064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9065 }
9066 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9067 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9068 if (!SWIG_IsOK(ecode2)) {
9069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9070 }
9071 arg2 = static_cast< double >(val2);
9072 if (arg1) (arg1)->m_x = arg2;
9073
9074 resultobj = SWIG_Py_Void();
9075 return resultobj;
9076 fail:
9077 return NULL;
9078 }
9079
9080
9081 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9082 PyObject *resultobj = 0;
9083 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9084 double result;
9085 void *argp1 = 0 ;
9086 int res1 = 0 ;
9087 PyObject *swig_obj[1] ;
9088
9089 if (!args) SWIG_fail;
9090 swig_obj[0] = args;
9091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9092 if (!SWIG_IsOK(res1)) {
9093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9094 }
9095 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9096 result = (double) ((arg1)->m_x);
9097 resultobj = SWIG_From_double(static_cast< double >(result));
9098 return resultobj;
9099 fail:
9100 return NULL;
9101 }
9102
9103
9104 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9105 PyObject *resultobj = 0;
9106 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9107 double arg2 ;
9108 void *argp1 = 0 ;
9109 int res1 = 0 ;
9110 double val2 ;
9111 int ecode2 = 0 ;
9112 PyObject *swig_obj[2] ;
9113
9114 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9116 if (!SWIG_IsOK(res1)) {
9117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9118 }
9119 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9120 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9121 if (!SWIG_IsOK(ecode2)) {
9122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9123 }
9124 arg2 = static_cast< double >(val2);
9125 if (arg1) (arg1)->m_y = arg2;
9126
9127 resultobj = SWIG_Py_Void();
9128 return resultobj;
9129 fail:
9130 return NULL;
9131 }
9132
9133
9134 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9135 PyObject *resultobj = 0;
9136 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9137 double result;
9138 void *argp1 = 0 ;
9139 int res1 = 0 ;
9140 PyObject *swig_obj[1] ;
9141
9142 if (!args) SWIG_fail;
9143 swig_obj[0] = args;
9144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9145 if (!SWIG_IsOK(res1)) {
9146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9147 }
9148 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9149 result = (double) ((arg1)->m_y);
9150 resultobj = SWIG_From_double(static_cast< double >(result));
9151 return resultobj;
9152 fail:
9153 return NULL;
9154 }
9155
9156
9157 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9158 PyObject *resultobj = 0;
9159 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9160 double arg2 = (double) 0 ;
9161 double arg3 = (double) 0 ;
9162 void *argp1 = 0 ;
9163 int res1 = 0 ;
9164 double val2 ;
9165 int ecode2 = 0 ;
9166 double val3 ;
9167 int ecode3 = 0 ;
9168 PyObject * obj0 = 0 ;
9169 PyObject * obj1 = 0 ;
9170 PyObject * obj2 = 0 ;
9171 char * kwnames[] = {
9172 (char *) "self",(char *) "x",(char *) "y", NULL
9173 };
9174
9175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9177 if (!SWIG_IsOK(res1)) {
9178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9179 }
9180 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9181 if (obj1) {
9182 ecode2 = SWIG_AsVal_double(obj1, &val2);
9183 if (!SWIG_IsOK(ecode2)) {
9184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9185 }
9186 arg2 = static_cast< double >(val2);
9187 }
9188 if (obj2) {
9189 ecode3 = SWIG_AsVal_double(obj2, &val3);
9190 if (!SWIG_IsOK(ecode3)) {
9191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9192 }
9193 arg3 = static_cast< double >(val3);
9194 }
9195 {
9196 PyThreadState* __tstate = wxPyBeginAllowThreads();
9197 wxPoint2D_Set(arg1,arg2,arg3);
9198 wxPyEndAllowThreads(__tstate);
9199 if (PyErr_Occurred()) SWIG_fail;
9200 }
9201 resultobj = SWIG_Py_Void();
9202 return resultobj;
9203 fail:
9204 return NULL;
9205 }
9206
9207
9208 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9209 PyObject *resultobj = 0;
9210 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9211 PyObject *result = 0 ;
9212 void *argp1 = 0 ;
9213 int res1 = 0 ;
9214 PyObject *swig_obj[1] ;
9215
9216 if (!args) SWIG_fail;
9217 swig_obj[0] = args;
9218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9219 if (!SWIG_IsOK(res1)) {
9220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9221 }
9222 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9223 {
9224 PyThreadState* __tstate = wxPyBeginAllowThreads();
9225 result = (PyObject *)wxPoint2D_Get(arg1);
9226 wxPyEndAllowThreads(__tstate);
9227 if (PyErr_Occurred()) SWIG_fail;
9228 }
9229 resultobj = result;
9230 return resultobj;
9231 fail:
9232 return NULL;
9233 }
9234
9235
9236 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9237 PyObject *obj;
9238 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9239 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9240 return SWIG_Py_Void();
9241 }
9242
9243 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9244 return SWIG_Python_InitShadowInstance(args);
9245 }
9246
9247 SWIGINTERN int DefaultPosition_set(PyObject *) {
9248 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
9249 return 1;
9250 }
9251
9252
9253 SWIGINTERN PyObject *DefaultPosition_get(void) {
9254 PyObject *pyobj = 0;
9255
9256 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9257 return pyobj;
9258 }
9259
9260
9261 SWIGINTERN int DefaultSize_set(PyObject *) {
9262 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9263 return 1;
9264 }
9265
9266
9267 SWIGINTERN PyObject *DefaultSize_get(void) {
9268 PyObject *pyobj = 0;
9269
9270 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9271 return pyobj;
9272 }
9273
9274
9275 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9276 PyObject *resultobj = 0;
9277 PyObject *arg1 = (PyObject *) 0 ;
9278 wxPyInputStream *result = 0 ;
9279 PyObject * obj0 = 0 ;
9280 char * kwnames[] = {
9281 (char *) "p", NULL
9282 };
9283
9284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9285 arg1 = obj0;
9286 {
9287 PyThreadState* __tstate = wxPyBeginAllowThreads();
9288 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9289 wxPyEndAllowThreads(__tstate);
9290 if (PyErr_Occurred()) SWIG_fail;
9291 }
9292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9293 return resultobj;
9294 fail:
9295 return NULL;
9296 }
9297
9298
9299 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9300 PyObject *resultobj = 0;
9301 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9302 void *argp1 = 0 ;
9303 int res1 = 0 ;
9304 PyObject *swig_obj[1] ;
9305
9306 if (!args) SWIG_fail;
9307 swig_obj[0] = args;
9308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9309 if (!SWIG_IsOK(res1)) {
9310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9311 }
9312 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9313 {
9314 PyThreadState* __tstate = wxPyBeginAllowThreads();
9315 delete arg1;
9316
9317 wxPyEndAllowThreads(__tstate);
9318 if (PyErr_Occurred()) SWIG_fail;
9319 }
9320 resultobj = SWIG_Py_Void();
9321 return resultobj;
9322 fail:
9323 return NULL;
9324 }
9325
9326
9327 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9328 PyObject *resultobj = 0;
9329 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9330 void *argp1 = 0 ;
9331 int res1 = 0 ;
9332 PyObject *swig_obj[1] ;
9333
9334 if (!args) SWIG_fail;
9335 swig_obj[0] = args;
9336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9337 if (!SWIG_IsOK(res1)) {
9338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9339 }
9340 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9341 {
9342 PyThreadState* __tstate = wxPyBeginAllowThreads();
9343 (arg1)->close();
9344 wxPyEndAllowThreads(__tstate);
9345 if (PyErr_Occurred()) SWIG_fail;
9346 }
9347 resultobj = SWIG_Py_Void();
9348 return resultobj;
9349 fail:
9350 return NULL;
9351 }
9352
9353
9354 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9355 PyObject *resultobj = 0;
9356 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9357 void *argp1 = 0 ;
9358 int res1 = 0 ;
9359 PyObject *swig_obj[1] ;
9360
9361 if (!args) SWIG_fail;
9362 swig_obj[0] = args;
9363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9364 if (!SWIG_IsOK(res1)) {
9365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9366 }
9367 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9368 {
9369 PyThreadState* __tstate = wxPyBeginAllowThreads();
9370 (arg1)->flush();
9371 wxPyEndAllowThreads(__tstate);
9372 if (PyErr_Occurred()) SWIG_fail;
9373 }
9374 resultobj = SWIG_Py_Void();
9375 return resultobj;
9376 fail:
9377 return NULL;
9378 }
9379
9380
9381 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9382 PyObject *resultobj = 0;
9383 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9384 bool result;
9385 void *argp1 = 0 ;
9386 int res1 = 0 ;
9387 PyObject *swig_obj[1] ;
9388
9389 if (!args) SWIG_fail;
9390 swig_obj[0] = args;
9391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9392 if (!SWIG_IsOK(res1)) {
9393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9394 }
9395 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9396 {
9397 PyThreadState* __tstate = wxPyBeginAllowThreads();
9398 result = (bool)(arg1)->eof();
9399 wxPyEndAllowThreads(__tstate);
9400 if (PyErr_Occurred()) SWIG_fail;
9401 }
9402 {
9403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9404 }
9405 return resultobj;
9406 fail:
9407 return NULL;
9408 }
9409
9410
9411 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9412 PyObject *resultobj = 0;
9413 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9414 int arg2 = (int) -1 ;
9415 PyObject *result = 0 ;
9416 void *argp1 = 0 ;
9417 int res1 = 0 ;
9418 int val2 ;
9419 int ecode2 = 0 ;
9420 PyObject * obj0 = 0 ;
9421 PyObject * obj1 = 0 ;
9422 char * kwnames[] = {
9423 (char *) "self",(char *) "size", NULL
9424 };
9425
9426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9428 if (!SWIG_IsOK(res1)) {
9429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9430 }
9431 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9432 if (obj1) {
9433 ecode2 = SWIG_AsVal_int(obj1, &val2);
9434 if (!SWIG_IsOK(ecode2)) {
9435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9436 }
9437 arg2 = static_cast< int >(val2);
9438 }
9439 {
9440 PyThreadState* __tstate = wxPyBeginAllowThreads();
9441 result = (PyObject *)(arg1)->read(arg2);
9442 wxPyEndAllowThreads(__tstate);
9443 if (PyErr_Occurred()) SWIG_fail;
9444 }
9445 resultobj = result;
9446 return resultobj;
9447 fail:
9448 return NULL;
9449 }
9450
9451
9452 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9453 PyObject *resultobj = 0;
9454 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9455 int arg2 = (int) -1 ;
9456 PyObject *result = 0 ;
9457 void *argp1 = 0 ;
9458 int res1 = 0 ;
9459 int val2 ;
9460 int ecode2 = 0 ;
9461 PyObject * obj0 = 0 ;
9462 PyObject * obj1 = 0 ;
9463 char * kwnames[] = {
9464 (char *) "self",(char *) "size", NULL
9465 };
9466
9467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9469 if (!SWIG_IsOK(res1)) {
9470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9471 }
9472 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9473 if (obj1) {
9474 ecode2 = SWIG_AsVal_int(obj1, &val2);
9475 if (!SWIG_IsOK(ecode2)) {
9476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9477 }
9478 arg2 = static_cast< int >(val2);
9479 }
9480 {
9481 PyThreadState* __tstate = wxPyBeginAllowThreads();
9482 result = (PyObject *)(arg1)->readline(arg2);
9483 wxPyEndAllowThreads(__tstate);
9484 if (PyErr_Occurred()) SWIG_fail;
9485 }
9486 resultobj = result;
9487 return resultobj;
9488 fail:
9489 return NULL;
9490 }
9491
9492
9493 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9494 PyObject *resultobj = 0;
9495 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9496 int arg2 = (int) -1 ;
9497 PyObject *result = 0 ;
9498 void *argp1 = 0 ;
9499 int res1 = 0 ;
9500 int val2 ;
9501 int ecode2 = 0 ;
9502 PyObject * obj0 = 0 ;
9503 PyObject * obj1 = 0 ;
9504 char * kwnames[] = {
9505 (char *) "self",(char *) "sizehint", NULL
9506 };
9507
9508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9510 if (!SWIG_IsOK(res1)) {
9511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9512 }
9513 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9514 if (obj1) {
9515 ecode2 = SWIG_AsVal_int(obj1, &val2);
9516 if (!SWIG_IsOK(ecode2)) {
9517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9518 }
9519 arg2 = static_cast< int >(val2);
9520 }
9521 {
9522 PyThreadState* __tstate = wxPyBeginAllowThreads();
9523 result = (PyObject *)(arg1)->readlines(arg2);
9524 wxPyEndAllowThreads(__tstate);
9525 if (PyErr_Occurred()) SWIG_fail;
9526 }
9527 resultobj = result;
9528 return resultobj;
9529 fail:
9530 return NULL;
9531 }
9532
9533
9534 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9535 PyObject *resultobj = 0;
9536 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9537 int arg2 ;
9538 int arg3 = (int) 0 ;
9539 void *argp1 = 0 ;
9540 int res1 = 0 ;
9541 int val2 ;
9542 int ecode2 = 0 ;
9543 int val3 ;
9544 int ecode3 = 0 ;
9545 PyObject * obj0 = 0 ;
9546 PyObject * obj1 = 0 ;
9547 PyObject * obj2 = 0 ;
9548 char * kwnames[] = {
9549 (char *) "self",(char *) "offset",(char *) "whence", NULL
9550 };
9551
9552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9554 if (!SWIG_IsOK(res1)) {
9555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9556 }
9557 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9558 ecode2 = SWIG_AsVal_int(obj1, &val2);
9559 if (!SWIG_IsOK(ecode2)) {
9560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9561 }
9562 arg2 = static_cast< int >(val2);
9563 if (obj2) {
9564 ecode3 = SWIG_AsVal_int(obj2, &val3);
9565 if (!SWIG_IsOK(ecode3)) {
9566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9567 }
9568 arg3 = static_cast< int >(val3);
9569 }
9570 {
9571 PyThreadState* __tstate = wxPyBeginAllowThreads();
9572 (arg1)->seek(arg2,arg3);
9573 wxPyEndAllowThreads(__tstate);
9574 if (PyErr_Occurred()) SWIG_fail;
9575 }
9576 resultobj = SWIG_Py_Void();
9577 return resultobj;
9578 fail:
9579 return NULL;
9580 }
9581
9582
9583 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9584 PyObject *resultobj = 0;
9585 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9586 int result;
9587 void *argp1 = 0 ;
9588 int res1 = 0 ;
9589 PyObject *swig_obj[1] ;
9590
9591 if (!args) SWIG_fail;
9592 swig_obj[0] = args;
9593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9594 if (!SWIG_IsOK(res1)) {
9595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9596 }
9597 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9598 {
9599 PyThreadState* __tstate = wxPyBeginAllowThreads();
9600 result = (int)(arg1)->tell();
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 resultobj = SWIG_From_int(static_cast< int >(result));
9605 return resultobj;
9606 fail:
9607 return NULL;
9608 }
9609
9610
9611 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9612 PyObject *resultobj = 0;
9613 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9614 char result;
9615 void *argp1 = 0 ;
9616 int res1 = 0 ;
9617 PyObject *swig_obj[1] ;
9618
9619 if (!args) SWIG_fail;
9620 swig_obj[0] = args;
9621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9622 if (!SWIG_IsOK(res1)) {
9623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9624 }
9625 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9626 {
9627 PyThreadState* __tstate = wxPyBeginAllowThreads();
9628 result = (char)(arg1)->Peek();
9629 wxPyEndAllowThreads(__tstate);
9630 if (PyErr_Occurred()) SWIG_fail;
9631 }
9632 resultobj = SWIG_From_char(static_cast< char >(result));
9633 return resultobj;
9634 fail:
9635 return NULL;
9636 }
9637
9638
9639 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9640 PyObject *resultobj = 0;
9641 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9642 char result;
9643 void *argp1 = 0 ;
9644 int res1 = 0 ;
9645 PyObject *swig_obj[1] ;
9646
9647 if (!args) SWIG_fail;
9648 swig_obj[0] = args;
9649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9650 if (!SWIG_IsOK(res1)) {
9651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9652 }
9653 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9654 {
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 result = (char)(arg1)->GetC();
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 resultobj = SWIG_From_char(static_cast< char >(result));
9661 return resultobj;
9662 fail:
9663 return NULL;
9664 }
9665
9666
9667 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9668 PyObject *resultobj = 0;
9669 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9670 size_t result;
9671 void *argp1 = 0 ;
9672 int res1 = 0 ;
9673 PyObject *swig_obj[1] ;
9674
9675 if (!args) SWIG_fail;
9676 swig_obj[0] = args;
9677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9678 if (!SWIG_IsOK(res1)) {
9679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9680 }
9681 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9682 {
9683 PyThreadState* __tstate = wxPyBeginAllowThreads();
9684 result = (size_t)(arg1)->LastRead();
9685 wxPyEndAllowThreads(__tstate);
9686 if (PyErr_Occurred()) SWIG_fail;
9687 }
9688 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9689 return resultobj;
9690 fail:
9691 return NULL;
9692 }
9693
9694
9695 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9696 PyObject *resultobj = 0;
9697 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9698 bool result;
9699 void *argp1 = 0 ;
9700 int res1 = 0 ;
9701 PyObject *swig_obj[1] ;
9702
9703 if (!args) SWIG_fail;
9704 swig_obj[0] = args;
9705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9706 if (!SWIG_IsOK(res1)) {
9707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9708 }
9709 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9710 {
9711 PyThreadState* __tstate = wxPyBeginAllowThreads();
9712 result = (bool)(arg1)->CanRead();
9713 wxPyEndAllowThreads(__tstate);
9714 if (PyErr_Occurred()) SWIG_fail;
9715 }
9716 {
9717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9718 }
9719 return resultobj;
9720 fail:
9721 return NULL;
9722 }
9723
9724
9725 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9726 PyObject *resultobj = 0;
9727 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9728 bool result;
9729 void *argp1 = 0 ;
9730 int res1 = 0 ;
9731 PyObject *swig_obj[1] ;
9732
9733 if (!args) SWIG_fail;
9734 swig_obj[0] = args;
9735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9736 if (!SWIG_IsOK(res1)) {
9737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9738 }
9739 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9740 {
9741 PyThreadState* __tstate = wxPyBeginAllowThreads();
9742 result = (bool)(arg1)->Eof();
9743 wxPyEndAllowThreads(__tstate);
9744 if (PyErr_Occurred()) SWIG_fail;
9745 }
9746 {
9747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9748 }
9749 return resultobj;
9750 fail:
9751 return NULL;
9752 }
9753
9754
9755 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9756 PyObject *resultobj = 0;
9757 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9758 char arg2 ;
9759 bool result;
9760 void *argp1 = 0 ;
9761 int res1 = 0 ;
9762 char val2 ;
9763 int ecode2 = 0 ;
9764 PyObject * obj0 = 0 ;
9765 PyObject * obj1 = 0 ;
9766 char * kwnames[] = {
9767 (char *) "self",(char *) "c", NULL
9768 };
9769
9770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9772 if (!SWIG_IsOK(res1)) {
9773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9774 }
9775 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9776 ecode2 = SWIG_AsVal_char(obj1, &val2);
9777 if (!SWIG_IsOK(ecode2)) {
9778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9779 }
9780 arg2 = static_cast< char >(val2);
9781 {
9782 PyThreadState* __tstate = wxPyBeginAllowThreads();
9783 result = (bool)(arg1)->Ungetch(arg2);
9784 wxPyEndAllowThreads(__tstate);
9785 if (PyErr_Occurred()) SWIG_fail;
9786 }
9787 {
9788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9789 }
9790 return resultobj;
9791 fail:
9792 return NULL;
9793 }
9794
9795
9796 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9797 PyObject *resultobj = 0;
9798 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9799 long arg2 ;
9800 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9801 long result;
9802 void *argp1 = 0 ;
9803 int res1 = 0 ;
9804 long val2 ;
9805 int ecode2 = 0 ;
9806 int val3 ;
9807 int ecode3 = 0 ;
9808 PyObject * obj0 = 0 ;
9809 PyObject * obj1 = 0 ;
9810 PyObject * obj2 = 0 ;
9811 char * kwnames[] = {
9812 (char *) "self",(char *) "pos",(char *) "mode", NULL
9813 };
9814
9815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9817 if (!SWIG_IsOK(res1)) {
9818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9819 }
9820 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9821 ecode2 = SWIG_AsVal_long(obj1, &val2);
9822 if (!SWIG_IsOK(ecode2)) {
9823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9824 }
9825 arg2 = static_cast< long >(val2);
9826 if (obj2) {
9827 ecode3 = SWIG_AsVal_int(obj2, &val3);
9828 if (!SWIG_IsOK(ecode3)) {
9829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9830 }
9831 arg3 = static_cast< wxSeekMode >(val3);
9832 }
9833 {
9834 PyThreadState* __tstate = wxPyBeginAllowThreads();
9835 result = (long)(arg1)->SeekI(arg2,arg3);
9836 wxPyEndAllowThreads(__tstate);
9837 if (PyErr_Occurred()) SWIG_fail;
9838 }
9839 resultobj = SWIG_From_long(static_cast< long >(result));
9840 return resultobj;
9841 fail:
9842 return NULL;
9843 }
9844
9845
9846 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9847 PyObject *resultobj = 0;
9848 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9849 long result;
9850 void *argp1 = 0 ;
9851 int res1 = 0 ;
9852 PyObject *swig_obj[1] ;
9853
9854 if (!args) SWIG_fail;
9855 swig_obj[0] = args;
9856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9857 if (!SWIG_IsOK(res1)) {
9858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9859 }
9860 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9861 {
9862 PyThreadState* __tstate = wxPyBeginAllowThreads();
9863 result = (long)(arg1)->TellI();
9864 wxPyEndAllowThreads(__tstate);
9865 if (PyErr_Occurred()) SWIG_fail;
9866 }
9867 resultobj = SWIG_From_long(static_cast< long >(result));
9868 return resultobj;
9869 fail:
9870 return NULL;
9871 }
9872
9873
9874 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9875 PyObject *obj;
9876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9877 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9878 return SWIG_Py_Void();
9879 }
9880
9881 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9882 return SWIG_Python_InitShadowInstance(args);
9883 }
9884
9885 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9886 PyObject *resultobj = 0;
9887 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9888 PyObject *arg2 = (PyObject *) 0 ;
9889 void *argp1 = 0 ;
9890 int res1 = 0 ;
9891 PyObject * obj0 = 0 ;
9892 PyObject * obj1 = 0 ;
9893 char * kwnames[] = {
9894 (char *) "self",(char *) "obj", NULL
9895 };
9896
9897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9899 if (!SWIG_IsOK(res1)) {
9900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9901 }
9902 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9903 arg2 = obj1;
9904 {
9905 PyThreadState* __tstate = wxPyBeginAllowThreads();
9906 wxOutputStream_write(arg1,arg2);
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 resultobj = SWIG_Py_Void();
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9918 PyObject *resultobj = 0;
9919 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9920 size_t result;
9921 void *argp1 = 0 ;
9922 int res1 = 0 ;
9923 PyObject *swig_obj[1] ;
9924
9925 if (!args) SWIG_fail;
9926 swig_obj[0] = args;
9927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9928 if (!SWIG_IsOK(res1)) {
9929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9930 }
9931 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9932 {
9933 PyThreadState* __tstate = wxPyBeginAllowThreads();
9934 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9939 return resultobj;
9940 fail:
9941 return NULL;
9942 }
9943
9944
9945 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9946 PyObject *obj;
9947 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9948 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9949 return SWIG_Py_Void();
9950 }
9951
9952 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9953 PyObject *resultobj = 0;
9954 wxInputStream *arg1 = (wxInputStream *) 0 ;
9955 wxString *arg2 = 0 ;
9956 wxString *arg3 = 0 ;
9957 wxString *arg4 = 0 ;
9958 wxDateTime arg5 ;
9959 wxFSFile *result = 0 ;
9960 wxPyInputStream *temp1 ;
9961 bool temp2 = false ;
9962 bool temp3 = false ;
9963 bool temp4 = false ;
9964 void *argp5 ;
9965 int res5 = 0 ;
9966 PyObject * obj0 = 0 ;
9967 PyObject * obj1 = 0 ;
9968 PyObject * obj2 = 0 ;
9969 PyObject * obj3 = 0 ;
9970 PyObject * obj4 = 0 ;
9971 char * kwnames[] = {
9972 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9973 };
9974
9975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9976 {
9977 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9978 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9979 } else {
9980 PyErr_Clear(); // clear the failure of the wxPyConvert above
9981 arg1 = wxPyCBInputStream_create(obj0, true);
9982 if (arg1 == NULL) {
9983 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9984 SWIG_fail;
9985 }
9986 }
9987 }
9988 {
9989 arg2 = wxString_in_helper(obj1);
9990 if (arg2 == NULL) SWIG_fail;
9991 temp2 = true;
9992 }
9993 {
9994 arg3 = wxString_in_helper(obj2);
9995 if (arg3 == NULL) SWIG_fail;
9996 temp3 = true;
9997 }
9998 {
9999 arg4 = wxString_in_helper(obj3);
10000 if (arg4 == NULL) SWIG_fail;
10001 temp4 = true;
10002 }
10003 {
10004 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
10005 if (!SWIG_IsOK(res5)) {
10006 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
10007 }
10008 if (!argp5) {
10009 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
10010 } else {
10011 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
10012 arg5 = *temp;
10013 if (SWIG_IsNewObj(res5)) delete temp;
10014 }
10015 }
10016 {
10017 PyThreadState* __tstate = wxPyBeginAllowThreads();
10018 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
10019 wxPyEndAllowThreads(__tstate);
10020 if (PyErr_Occurred()) SWIG_fail;
10021 }
10022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
10023 {
10024 if (temp2)
10025 delete arg2;
10026 }
10027 {
10028 if (temp3)
10029 delete arg3;
10030 }
10031 {
10032 if (temp4)
10033 delete arg4;
10034 }
10035 return resultobj;
10036 fail:
10037 {
10038 if (temp2)
10039 delete arg2;
10040 }
10041 {
10042 if (temp3)
10043 delete arg3;
10044 }
10045 {
10046 if (temp4)
10047 delete arg4;
10048 }
10049 return NULL;
10050 }
10051
10052
10053 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10054 PyObject *resultobj = 0;
10055 wxFSFile *arg1 = (wxFSFile *) 0 ;
10056 void *argp1 = 0 ;
10057 int res1 = 0 ;
10058 PyObject *swig_obj[1] ;
10059
10060 if (!args) SWIG_fail;
10061 swig_obj[0] = args;
10062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
10063 if (!SWIG_IsOK(res1)) {
10064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
10065 }
10066 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10067 {
10068 PyThreadState* __tstate = wxPyBeginAllowThreads();
10069 delete arg1;
10070
10071 wxPyEndAllowThreads(__tstate);
10072 if (PyErr_Occurred()) SWIG_fail;
10073 }
10074 resultobj = SWIG_Py_Void();
10075 return resultobj;
10076 fail:
10077 return NULL;
10078 }
10079
10080
10081 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10082 PyObject *resultobj = 0;
10083 wxFSFile *arg1 = (wxFSFile *) 0 ;
10084 wxInputStream *result = 0 ;
10085 void *argp1 = 0 ;
10086 int res1 = 0 ;
10087 PyObject *swig_obj[1] ;
10088
10089 if (!args) SWIG_fail;
10090 swig_obj[0] = args;
10091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10092 if (!SWIG_IsOK(res1)) {
10093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10094 }
10095 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10096 {
10097 PyThreadState* __tstate = wxPyBeginAllowThreads();
10098 result = (wxInputStream *)(arg1)->GetStream();
10099 wxPyEndAllowThreads(__tstate);
10100 if (PyErr_Occurred()) SWIG_fail;
10101 }
10102 {
10103 wxPyInputStream * _ptr = NULL;
10104
10105 if (result) {
10106 _ptr = new wxPyInputStream(result);
10107 }
10108 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10109 }
10110 return resultobj;
10111 fail:
10112 return NULL;
10113 }
10114
10115
10116 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10117 PyObject *resultobj = 0;
10118 wxFSFile *arg1 = (wxFSFile *) 0 ;
10119 void *argp1 = 0 ;
10120 int res1 = 0 ;
10121 PyObject *swig_obj[1] ;
10122
10123 if (!args) SWIG_fail;
10124 swig_obj[0] = args;
10125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10126 if (!SWIG_IsOK(res1)) {
10127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10128 }
10129 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10130 {
10131 PyThreadState* __tstate = wxPyBeginAllowThreads();
10132 (arg1)->DetachStream();
10133 wxPyEndAllowThreads(__tstate);
10134 if (PyErr_Occurred()) SWIG_fail;
10135 }
10136 resultobj = SWIG_Py_Void();
10137 return resultobj;
10138 fail:
10139 return NULL;
10140 }
10141
10142
10143 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10144 PyObject *resultobj = 0;
10145 wxFSFile *arg1 = (wxFSFile *) 0 ;
10146 wxString *result = 0 ;
10147 void *argp1 = 0 ;
10148 int res1 = 0 ;
10149 PyObject *swig_obj[1] ;
10150
10151 if (!args) SWIG_fail;
10152 swig_obj[0] = args;
10153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10154 if (!SWIG_IsOK(res1)) {
10155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
10156 }
10157 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10158 {
10159 PyThreadState* __tstate = wxPyBeginAllowThreads();
10160 {
10161 wxString const &_result_ref = (arg1)->GetMimeType();
10162 result = (wxString *) &_result_ref;
10163 }
10164 wxPyEndAllowThreads(__tstate);
10165 if (PyErr_Occurred()) SWIG_fail;
10166 }
10167 {
10168 #if wxUSE_UNICODE
10169 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10170 #else
10171 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10172 #endif
10173 }
10174 return resultobj;
10175 fail:
10176 return NULL;
10177 }
10178
10179
10180 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10181 PyObject *resultobj = 0;
10182 wxFSFile *arg1 = (wxFSFile *) 0 ;
10183 wxString *result = 0 ;
10184 void *argp1 = 0 ;
10185 int res1 = 0 ;
10186 PyObject *swig_obj[1] ;
10187
10188 if (!args) SWIG_fail;
10189 swig_obj[0] = args;
10190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10191 if (!SWIG_IsOK(res1)) {
10192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
10193 }
10194 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10195 {
10196 PyThreadState* __tstate = wxPyBeginAllowThreads();
10197 {
10198 wxString const &_result_ref = (arg1)->GetLocation();
10199 result = (wxString *) &_result_ref;
10200 }
10201 wxPyEndAllowThreads(__tstate);
10202 if (PyErr_Occurred()) SWIG_fail;
10203 }
10204 {
10205 #if wxUSE_UNICODE
10206 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10207 #else
10208 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10209 #endif
10210 }
10211 return resultobj;
10212 fail:
10213 return NULL;
10214 }
10215
10216
10217 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10218 PyObject *resultobj = 0;
10219 wxFSFile *arg1 = (wxFSFile *) 0 ;
10220 wxString *result = 0 ;
10221 void *argp1 = 0 ;
10222 int res1 = 0 ;
10223 PyObject *swig_obj[1] ;
10224
10225 if (!args) SWIG_fail;
10226 swig_obj[0] = args;
10227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10228 if (!SWIG_IsOK(res1)) {
10229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
10230 }
10231 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10232 {
10233 PyThreadState* __tstate = wxPyBeginAllowThreads();
10234 {
10235 wxString const &_result_ref = (arg1)->GetAnchor();
10236 result = (wxString *) &_result_ref;
10237 }
10238 wxPyEndAllowThreads(__tstate);
10239 if (PyErr_Occurred()) SWIG_fail;
10240 }
10241 {
10242 #if wxUSE_UNICODE
10243 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10244 #else
10245 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10246 #endif
10247 }
10248 return resultobj;
10249 fail:
10250 return NULL;
10251 }
10252
10253
10254 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10255 PyObject *resultobj = 0;
10256 wxFSFile *arg1 = (wxFSFile *) 0 ;
10257 wxDateTime result;
10258 void *argp1 = 0 ;
10259 int res1 = 0 ;
10260 PyObject *swig_obj[1] ;
10261
10262 if (!args) SWIG_fail;
10263 swig_obj[0] = args;
10264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10265 if (!SWIG_IsOK(res1)) {
10266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10267 }
10268 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10269 {
10270 PyThreadState* __tstate = wxPyBeginAllowThreads();
10271 result = (arg1)->GetModificationTime();
10272 wxPyEndAllowThreads(__tstate);
10273 if (PyErr_Occurred()) SWIG_fail;
10274 }
10275 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10276 return resultobj;
10277 fail:
10278 return NULL;
10279 }
10280
10281
10282 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10283 PyObject *obj;
10284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10285 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10286 return SWIG_Py_Void();
10287 }
10288
10289 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10290 return SWIG_Python_InitShadowInstance(args);
10291 }
10292
10293 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10294 PyObject *resultobj = 0;
10295 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10296 void *argp1 = 0 ;
10297 int res1 = 0 ;
10298 PyObject *swig_obj[1] ;
10299
10300 if (!args) SWIG_fail;
10301 swig_obj[0] = args;
10302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10303 if (!SWIG_IsOK(res1)) {
10304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10305 }
10306 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10307 {
10308 PyThreadState* __tstate = wxPyBeginAllowThreads();
10309 delete arg1;
10310
10311 wxPyEndAllowThreads(__tstate);
10312 if (PyErr_Occurred()) SWIG_fail;
10313 }
10314 resultobj = SWIG_Py_Void();
10315 return resultobj;
10316 fail:
10317 return NULL;
10318 }
10319
10320
10321 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10322 PyObject *obj;
10323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10324 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10325 return SWIG_Py_Void();
10326 }
10327
10328 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10329 PyObject *resultobj = 0;
10330 wxPyFileSystemHandler *result = 0 ;
10331
10332 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10333 {
10334 PyThreadState* __tstate = wxPyBeginAllowThreads();
10335 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10336 wxPyEndAllowThreads(__tstate);
10337 if (PyErr_Occurred()) SWIG_fail;
10338 }
10339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10340 return resultobj;
10341 fail:
10342 return NULL;
10343 }
10344
10345
10346 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10347 PyObject *resultobj = 0;
10348 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10349 PyObject *arg2 = (PyObject *) 0 ;
10350 PyObject *arg3 = (PyObject *) 0 ;
10351 void *argp1 = 0 ;
10352 int res1 = 0 ;
10353 PyObject * obj0 = 0 ;
10354 PyObject * obj1 = 0 ;
10355 PyObject * obj2 = 0 ;
10356 char * kwnames[] = {
10357 (char *) "self",(char *) "self",(char *) "_class", NULL
10358 };
10359
10360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10362 if (!SWIG_IsOK(res1)) {
10363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10364 }
10365 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10366 arg2 = obj1;
10367 arg3 = obj2;
10368 {
10369 PyThreadState* __tstate = wxPyBeginAllowThreads();
10370 (arg1)->_setCallbackInfo(arg2,arg3);
10371 wxPyEndAllowThreads(__tstate);
10372 if (PyErr_Occurred()) SWIG_fail;
10373 }
10374 resultobj = SWIG_Py_Void();
10375 return resultobj;
10376 fail:
10377 return NULL;
10378 }
10379
10380
10381 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10382 PyObject *resultobj = 0;
10383 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10384 wxString *arg2 = 0 ;
10385 bool result;
10386 void *argp1 = 0 ;
10387 int res1 = 0 ;
10388 bool temp2 = false ;
10389 PyObject * obj0 = 0 ;
10390 PyObject * obj1 = 0 ;
10391 char * kwnames[] = {
10392 (char *) "self",(char *) "location", NULL
10393 };
10394
10395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10397 if (!SWIG_IsOK(res1)) {
10398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10399 }
10400 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10401 {
10402 arg2 = wxString_in_helper(obj1);
10403 if (arg2 == NULL) SWIG_fail;
10404 temp2 = true;
10405 }
10406 {
10407 PyThreadState* __tstate = wxPyBeginAllowThreads();
10408 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10409 wxPyEndAllowThreads(__tstate);
10410 if (PyErr_Occurred()) SWIG_fail;
10411 }
10412 {
10413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10414 }
10415 {
10416 if (temp2)
10417 delete arg2;
10418 }
10419 return resultobj;
10420 fail:
10421 {
10422 if (temp2)
10423 delete arg2;
10424 }
10425 return NULL;
10426 }
10427
10428
10429 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10430 PyObject *resultobj = 0;
10431 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10432 wxFileSystem *arg2 = 0 ;
10433 wxString *arg3 = 0 ;
10434 wxFSFile *result = 0 ;
10435 void *argp1 = 0 ;
10436 int res1 = 0 ;
10437 void *argp2 = 0 ;
10438 int res2 = 0 ;
10439 bool temp3 = false ;
10440 PyObject * obj0 = 0 ;
10441 PyObject * obj1 = 0 ;
10442 PyObject * obj2 = 0 ;
10443 char * kwnames[] = {
10444 (char *) "self",(char *) "fs",(char *) "location", NULL
10445 };
10446
10447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10449 if (!SWIG_IsOK(res1)) {
10450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10451 }
10452 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10453 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10454 if (!SWIG_IsOK(res2)) {
10455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10456 }
10457 if (!argp2) {
10458 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10459 }
10460 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10461 {
10462 arg3 = wxString_in_helper(obj2);
10463 if (arg3 == NULL) SWIG_fail;
10464 temp3 = true;
10465 }
10466 {
10467 PyThreadState* __tstate = wxPyBeginAllowThreads();
10468 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10469 wxPyEndAllowThreads(__tstate);
10470 if (PyErr_Occurred()) SWIG_fail;
10471 }
10472 {
10473 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10474 }
10475 {
10476 if (temp3)
10477 delete arg3;
10478 }
10479 return resultobj;
10480 fail:
10481 {
10482 if (temp3)
10483 delete arg3;
10484 }
10485 return NULL;
10486 }
10487
10488
10489 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10490 PyObject *resultobj = 0;
10491 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10492 wxString *arg2 = 0 ;
10493 int arg3 = (int) 0 ;
10494 wxString result;
10495 void *argp1 = 0 ;
10496 int res1 = 0 ;
10497 bool temp2 = false ;
10498 int val3 ;
10499 int ecode3 = 0 ;
10500 PyObject * obj0 = 0 ;
10501 PyObject * obj1 = 0 ;
10502 PyObject * obj2 = 0 ;
10503 char * kwnames[] = {
10504 (char *) "self",(char *) "spec",(char *) "flags", NULL
10505 };
10506
10507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10509 if (!SWIG_IsOK(res1)) {
10510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10511 }
10512 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10513 {
10514 arg2 = wxString_in_helper(obj1);
10515 if (arg2 == NULL) SWIG_fail;
10516 temp2 = true;
10517 }
10518 if (obj2) {
10519 ecode3 = SWIG_AsVal_int(obj2, &val3);
10520 if (!SWIG_IsOK(ecode3)) {
10521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10522 }
10523 arg3 = static_cast< int >(val3);
10524 }
10525 {
10526 PyThreadState* __tstate = wxPyBeginAllowThreads();
10527 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10528 wxPyEndAllowThreads(__tstate);
10529 if (PyErr_Occurred()) SWIG_fail;
10530 }
10531 {
10532 #if wxUSE_UNICODE
10533 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10534 #else
10535 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10536 #endif
10537 }
10538 {
10539 if (temp2)
10540 delete arg2;
10541 }
10542 return resultobj;
10543 fail:
10544 {
10545 if (temp2)
10546 delete arg2;
10547 }
10548 return NULL;
10549 }
10550
10551
10552 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10553 PyObject *resultobj = 0;
10554 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10555 wxString result;
10556 void *argp1 = 0 ;
10557 int res1 = 0 ;
10558 PyObject *swig_obj[1] ;
10559
10560 if (!args) SWIG_fail;
10561 swig_obj[0] = args;
10562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10563 if (!SWIG_IsOK(res1)) {
10564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10565 }
10566 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10567 {
10568 PyThreadState* __tstate = wxPyBeginAllowThreads();
10569 result = (arg1)->FindNext();
10570 wxPyEndAllowThreads(__tstate);
10571 if (PyErr_Occurred()) SWIG_fail;
10572 }
10573 {
10574 #if wxUSE_UNICODE
10575 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10576 #else
10577 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10578 #endif
10579 }
10580 return resultobj;
10581 fail:
10582 return NULL;
10583 }
10584
10585
10586 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10587 PyObject *resultobj = 0;
10588 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10589 wxString *arg2 = 0 ;
10590 wxString result;
10591 void *argp1 = 0 ;
10592 int res1 = 0 ;
10593 bool temp2 = false ;
10594 PyObject * obj0 = 0 ;
10595 PyObject * obj1 = 0 ;
10596 char * kwnames[] = {
10597 (char *) "self",(char *) "location", NULL
10598 };
10599
10600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10602 if (!SWIG_IsOK(res1)) {
10603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10604 }
10605 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10606 {
10607 arg2 = wxString_in_helper(obj1);
10608 if (arg2 == NULL) SWIG_fail;
10609 temp2 = true;
10610 }
10611 {
10612 PyThreadState* __tstate = wxPyBeginAllowThreads();
10613 result = (arg1)->GetProtocol((wxString const &)*arg2);
10614 wxPyEndAllowThreads(__tstate);
10615 if (PyErr_Occurred()) SWIG_fail;
10616 }
10617 {
10618 #if wxUSE_UNICODE
10619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10620 #else
10621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10622 #endif
10623 }
10624 {
10625 if (temp2)
10626 delete arg2;
10627 }
10628 return resultobj;
10629 fail:
10630 {
10631 if (temp2)
10632 delete arg2;
10633 }
10634 return NULL;
10635 }
10636
10637
10638 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10639 PyObject *resultobj = 0;
10640 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10641 wxString *arg2 = 0 ;
10642 wxString result;
10643 void *argp1 = 0 ;
10644 int res1 = 0 ;
10645 bool temp2 = false ;
10646 PyObject * obj0 = 0 ;
10647 PyObject * obj1 = 0 ;
10648 char * kwnames[] = {
10649 (char *) "self",(char *) "location", NULL
10650 };
10651
10652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10654 if (!SWIG_IsOK(res1)) {
10655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10656 }
10657 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10658 {
10659 arg2 = wxString_in_helper(obj1);
10660 if (arg2 == NULL) SWIG_fail;
10661 temp2 = true;
10662 }
10663 {
10664 PyThreadState* __tstate = wxPyBeginAllowThreads();
10665 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10666 wxPyEndAllowThreads(__tstate);
10667 if (PyErr_Occurred()) SWIG_fail;
10668 }
10669 {
10670 #if wxUSE_UNICODE
10671 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10672 #else
10673 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10674 #endif
10675 }
10676 {
10677 if (temp2)
10678 delete arg2;
10679 }
10680 return resultobj;
10681 fail:
10682 {
10683 if (temp2)
10684 delete arg2;
10685 }
10686 return NULL;
10687 }
10688
10689
10690 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10691 PyObject *resultobj = 0;
10692 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10693 wxString *arg2 = 0 ;
10694 wxString result;
10695 void *argp1 = 0 ;
10696 int res1 = 0 ;
10697 bool temp2 = false ;
10698 PyObject * obj0 = 0 ;
10699 PyObject * obj1 = 0 ;
10700 char * kwnames[] = {
10701 (char *) "self",(char *) "location", NULL
10702 };
10703
10704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10706 if (!SWIG_IsOK(res1)) {
10707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10708 }
10709 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10710 {
10711 arg2 = wxString_in_helper(obj1);
10712 if (arg2 == NULL) SWIG_fail;
10713 temp2 = true;
10714 }
10715 {
10716 PyThreadState* __tstate = wxPyBeginAllowThreads();
10717 result = (arg1)->GetAnchor((wxString const &)*arg2);
10718 wxPyEndAllowThreads(__tstate);
10719 if (PyErr_Occurred()) SWIG_fail;
10720 }
10721 {
10722 #if wxUSE_UNICODE
10723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10724 #else
10725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10726 #endif
10727 }
10728 {
10729 if (temp2)
10730 delete arg2;
10731 }
10732 return resultobj;
10733 fail:
10734 {
10735 if (temp2)
10736 delete arg2;
10737 }
10738 return NULL;
10739 }
10740
10741
10742 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10743 PyObject *resultobj = 0;
10744 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10745 wxString *arg2 = 0 ;
10746 wxString result;
10747 void *argp1 = 0 ;
10748 int res1 = 0 ;
10749 bool temp2 = false ;
10750 PyObject * obj0 = 0 ;
10751 PyObject * obj1 = 0 ;
10752 char * kwnames[] = {
10753 (char *) "self",(char *) "location", NULL
10754 };
10755
10756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10758 if (!SWIG_IsOK(res1)) {
10759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10760 }
10761 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10762 {
10763 arg2 = wxString_in_helper(obj1);
10764 if (arg2 == NULL) SWIG_fail;
10765 temp2 = true;
10766 }
10767 {
10768 PyThreadState* __tstate = wxPyBeginAllowThreads();
10769 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10770 wxPyEndAllowThreads(__tstate);
10771 if (PyErr_Occurred()) SWIG_fail;
10772 }
10773 {
10774 #if wxUSE_UNICODE
10775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10776 #else
10777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10778 #endif
10779 }
10780 {
10781 if (temp2)
10782 delete arg2;
10783 }
10784 return resultobj;
10785 fail:
10786 {
10787 if (temp2)
10788 delete arg2;
10789 }
10790 return NULL;
10791 }
10792
10793
10794 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10795 PyObject *resultobj = 0;
10796 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10797 wxString *arg2 = 0 ;
10798 wxString result;
10799 void *argp1 = 0 ;
10800 int res1 = 0 ;
10801 bool temp2 = false ;
10802 PyObject * obj0 = 0 ;
10803 PyObject * obj1 = 0 ;
10804 char * kwnames[] = {
10805 (char *) "self",(char *) "location", NULL
10806 };
10807
10808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10810 if (!SWIG_IsOK(res1)) {
10811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10812 }
10813 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10814 {
10815 arg2 = wxString_in_helper(obj1);
10816 if (arg2 == NULL) SWIG_fail;
10817 temp2 = true;
10818 }
10819 {
10820 PyThreadState* __tstate = wxPyBeginAllowThreads();
10821 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10822 wxPyEndAllowThreads(__tstate);
10823 if (PyErr_Occurred()) SWIG_fail;
10824 }
10825 {
10826 #if wxUSE_UNICODE
10827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10828 #else
10829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10830 #endif
10831 }
10832 {
10833 if (temp2)
10834 delete arg2;
10835 }
10836 return resultobj;
10837 fail:
10838 {
10839 if (temp2)
10840 delete arg2;
10841 }
10842 return NULL;
10843 }
10844
10845
10846 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10847 PyObject *obj;
10848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10849 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10850 return SWIG_Py_Void();
10851 }
10852
10853 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10854 return SWIG_Python_InitShadowInstance(args);
10855 }
10856
10857 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10858 PyObject *resultobj = 0;
10859 wxFileSystem *result = 0 ;
10860
10861 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10862 {
10863 PyThreadState* __tstate = wxPyBeginAllowThreads();
10864 result = (wxFileSystem *)new wxFileSystem();
10865 wxPyEndAllowThreads(__tstate);
10866 if (PyErr_Occurred()) SWIG_fail;
10867 }
10868 {
10869 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10870 }
10871 return resultobj;
10872 fail:
10873 return NULL;
10874 }
10875
10876
10877 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10878 PyObject *resultobj = 0;
10879 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10880 void *argp1 = 0 ;
10881 int res1 = 0 ;
10882 PyObject *swig_obj[1] ;
10883
10884 if (!args) SWIG_fail;
10885 swig_obj[0] = args;
10886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10887 if (!SWIG_IsOK(res1)) {
10888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10889 }
10890 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10891 {
10892 PyThreadState* __tstate = wxPyBeginAllowThreads();
10893 delete arg1;
10894
10895 wxPyEndAllowThreads(__tstate);
10896 if (PyErr_Occurred()) SWIG_fail;
10897 }
10898 resultobj = SWIG_Py_Void();
10899 return resultobj;
10900 fail:
10901 return NULL;
10902 }
10903
10904
10905 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10906 PyObject *resultobj = 0;
10907 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10908 wxString *arg2 = 0 ;
10909 bool arg3 = (bool) false ;
10910 void *argp1 = 0 ;
10911 int res1 = 0 ;
10912 bool temp2 = false ;
10913 bool val3 ;
10914 int ecode3 = 0 ;
10915 PyObject * obj0 = 0 ;
10916 PyObject * obj1 = 0 ;
10917 PyObject * obj2 = 0 ;
10918 char * kwnames[] = {
10919 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10920 };
10921
10922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10924 if (!SWIG_IsOK(res1)) {
10925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10926 }
10927 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10928 {
10929 arg2 = wxString_in_helper(obj1);
10930 if (arg2 == NULL) SWIG_fail;
10931 temp2 = true;
10932 }
10933 if (obj2) {
10934 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10935 if (!SWIG_IsOK(ecode3)) {
10936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10937 }
10938 arg3 = static_cast< bool >(val3);
10939 }
10940 {
10941 PyThreadState* __tstate = wxPyBeginAllowThreads();
10942 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10943 wxPyEndAllowThreads(__tstate);
10944 if (PyErr_Occurred()) SWIG_fail;
10945 }
10946 resultobj = SWIG_Py_Void();
10947 {
10948 if (temp2)
10949 delete arg2;
10950 }
10951 return resultobj;
10952 fail:
10953 {
10954 if (temp2)
10955 delete arg2;
10956 }
10957 return NULL;
10958 }
10959
10960
10961 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10962 PyObject *resultobj = 0;
10963 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10964 wxString result;
10965 void *argp1 = 0 ;
10966 int res1 = 0 ;
10967 PyObject *swig_obj[1] ;
10968
10969 if (!args) SWIG_fail;
10970 swig_obj[0] = args;
10971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10972 if (!SWIG_IsOK(res1)) {
10973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10974 }
10975 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10976 {
10977 PyThreadState* __tstate = wxPyBeginAllowThreads();
10978 result = (arg1)->GetPath();
10979 wxPyEndAllowThreads(__tstate);
10980 if (PyErr_Occurred()) SWIG_fail;
10981 }
10982 {
10983 #if wxUSE_UNICODE
10984 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10985 #else
10986 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10987 #endif
10988 }
10989 return resultobj;
10990 fail:
10991 return NULL;
10992 }
10993
10994
10995 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10996 PyObject *resultobj = 0;
10997 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10998 wxString *arg2 = 0 ;
10999 wxFSFile *result = 0 ;
11000 void *argp1 = 0 ;
11001 int res1 = 0 ;
11002 bool temp2 = false ;
11003 PyObject * obj0 = 0 ;
11004 PyObject * obj1 = 0 ;
11005 char * kwnames[] = {
11006 (char *) "self",(char *) "location", NULL
11007 };
11008
11009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
11010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11011 if (!SWIG_IsOK(res1)) {
11012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11013 }
11014 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11015 {
11016 arg2 = wxString_in_helper(obj1);
11017 if (arg2 == NULL) SWIG_fail;
11018 temp2 = true;
11019 }
11020 {
11021 PyThreadState* __tstate = wxPyBeginAllowThreads();
11022 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
11023 wxPyEndAllowThreads(__tstate);
11024 if (PyErr_Occurred()) SWIG_fail;
11025 }
11026 {
11027 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11028 }
11029 {
11030 if (temp2)
11031 delete arg2;
11032 }
11033 return resultobj;
11034 fail:
11035 {
11036 if (temp2)
11037 delete arg2;
11038 }
11039 return NULL;
11040 }
11041
11042
11043 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11044 PyObject *resultobj = 0;
11045 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11046 wxString *arg2 = 0 ;
11047 int arg3 = (int) 0 ;
11048 wxString result;
11049 void *argp1 = 0 ;
11050 int res1 = 0 ;
11051 bool temp2 = false ;
11052 int val3 ;
11053 int ecode3 = 0 ;
11054 PyObject * obj0 = 0 ;
11055 PyObject * obj1 = 0 ;
11056 PyObject * obj2 = 0 ;
11057 char * kwnames[] = {
11058 (char *) "self",(char *) "spec",(char *) "flags", NULL
11059 };
11060
11061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11063 if (!SWIG_IsOK(res1)) {
11064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11065 }
11066 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11067 {
11068 arg2 = wxString_in_helper(obj1);
11069 if (arg2 == NULL) SWIG_fail;
11070 temp2 = true;
11071 }
11072 if (obj2) {
11073 ecode3 = SWIG_AsVal_int(obj2, &val3);
11074 if (!SWIG_IsOK(ecode3)) {
11075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
11076 }
11077 arg3 = static_cast< int >(val3);
11078 }
11079 {
11080 PyThreadState* __tstate = wxPyBeginAllowThreads();
11081 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11082 wxPyEndAllowThreads(__tstate);
11083 if (PyErr_Occurred()) SWIG_fail;
11084 }
11085 {
11086 #if wxUSE_UNICODE
11087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11088 #else
11089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11090 #endif
11091 }
11092 {
11093 if (temp2)
11094 delete arg2;
11095 }
11096 return resultobj;
11097 fail:
11098 {
11099 if (temp2)
11100 delete arg2;
11101 }
11102 return NULL;
11103 }
11104
11105
11106 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11107 PyObject *resultobj = 0;
11108 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11109 wxString result;
11110 void *argp1 = 0 ;
11111 int res1 = 0 ;
11112 PyObject *swig_obj[1] ;
11113
11114 if (!args) SWIG_fail;
11115 swig_obj[0] = args;
11116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11117 if (!SWIG_IsOK(res1)) {
11118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11119 }
11120 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11121 {
11122 PyThreadState* __tstate = wxPyBeginAllowThreads();
11123 result = (arg1)->FindNext();
11124 wxPyEndAllowThreads(__tstate);
11125 if (PyErr_Occurred()) SWIG_fail;
11126 }
11127 {
11128 #if wxUSE_UNICODE
11129 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11130 #else
11131 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11132 #endif
11133 }
11134 return resultobj;
11135 fail:
11136 return NULL;
11137 }
11138
11139
11140 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11141 PyObject *resultobj = 0;
11142 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11143 int res1 = 0 ;
11144 PyObject * obj0 = 0 ;
11145 char * kwnames[] = {
11146 (char *) "handler", NULL
11147 };
11148
11149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
11150 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
11151 if (!SWIG_IsOK(res1)) {
11152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11153 }
11154 {
11155 PyThreadState* __tstate = wxPyBeginAllowThreads();
11156 wxFileSystem::AddHandler(arg1);
11157 wxPyEndAllowThreads(__tstate);
11158 if (PyErr_Occurred()) SWIG_fail;
11159 }
11160 resultobj = SWIG_Py_Void();
11161 return resultobj;
11162 fail:
11163 return NULL;
11164 }
11165
11166
11167 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11168 PyObject *resultobj = 0;
11169 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11170 wxFileSystemHandler *result = 0 ;
11171 void *argp1 = 0 ;
11172 int res1 = 0 ;
11173 PyObject * obj0 = 0 ;
11174 char * kwnames[] = {
11175 (char *) "handler", NULL
11176 };
11177
11178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
11179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
11180 if (!SWIG_IsOK(res1)) {
11181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11182 }
11183 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
11184 {
11185 PyThreadState* __tstate = wxPyBeginAllowThreads();
11186 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
11191 return resultobj;
11192 fail:
11193 return NULL;
11194 }
11195
11196
11197 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11198 PyObject *resultobj = 0;
11199
11200 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
11201 {
11202 PyThreadState* __tstate = wxPyBeginAllowThreads();
11203 wxFileSystem::CleanUpHandlers();
11204 wxPyEndAllowThreads(__tstate);
11205 if (PyErr_Occurred()) SWIG_fail;
11206 }
11207 resultobj = SWIG_Py_Void();
11208 return resultobj;
11209 fail:
11210 return NULL;
11211 }
11212
11213
11214 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11215 PyObject *resultobj = 0;
11216 wxString *arg1 = 0 ;
11217 wxString result;
11218 bool temp1 = false ;
11219 PyObject * obj0 = 0 ;
11220 char * kwnames[] = {
11221 (char *) "filename", NULL
11222 };
11223
11224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
11225 {
11226 arg1 = wxString_in_helper(obj0);
11227 if (arg1 == NULL) SWIG_fail;
11228 temp1 = true;
11229 }
11230 {
11231 PyThreadState* __tstate = wxPyBeginAllowThreads();
11232 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
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 {
11244 if (temp1)
11245 delete arg1;
11246 }
11247 return resultobj;
11248 fail:
11249 {
11250 if (temp1)
11251 delete arg1;
11252 }
11253 return NULL;
11254 }
11255
11256
11257 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11258 PyObject *resultobj = 0;
11259 wxString *arg1 = 0 ;
11260 wxString result;
11261 bool temp1 = false ;
11262 PyObject * obj0 = 0 ;
11263 char * kwnames[] = {
11264 (char *) "url", NULL
11265 };
11266
11267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11268 {
11269 arg1 = wxString_in_helper(obj0);
11270 if (arg1 == NULL) SWIG_fail;
11271 temp1 = true;
11272 }
11273 {
11274 PyThreadState* __tstate = wxPyBeginAllowThreads();
11275 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11276 wxPyEndAllowThreads(__tstate);
11277 if (PyErr_Occurred()) SWIG_fail;
11278 }
11279 {
11280 #if wxUSE_UNICODE
11281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11282 #else
11283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11284 #endif
11285 }
11286 {
11287 if (temp1)
11288 delete arg1;
11289 }
11290 return resultobj;
11291 fail:
11292 {
11293 if (temp1)
11294 delete arg1;
11295 }
11296 return NULL;
11297 }
11298
11299
11300 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11301 PyObject *obj;
11302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11303 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11304 return SWIG_Py_Void();
11305 }
11306
11307 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11308 return SWIG_Python_InitShadowInstance(args);
11309 }
11310
11311 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11312 PyObject *resultobj = 0;
11313 wxInternetFSHandler *result = 0 ;
11314
11315 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11316 {
11317 PyThreadState* __tstate = wxPyBeginAllowThreads();
11318 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11319 wxPyEndAllowThreads(__tstate);
11320 if (PyErr_Occurred()) SWIG_fail;
11321 }
11322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11323 return resultobj;
11324 fail:
11325 return NULL;
11326 }
11327
11328
11329 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11330 PyObject *resultobj = 0;
11331 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11332 wxString *arg2 = 0 ;
11333 bool result;
11334 void *argp1 = 0 ;
11335 int res1 = 0 ;
11336 bool temp2 = false ;
11337 PyObject * obj0 = 0 ;
11338 PyObject * obj1 = 0 ;
11339 char * kwnames[] = {
11340 (char *) "self",(char *) "location", NULL
11341 };
11342
11343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11345 if (!SWIG_IsOK(res1)) {
11346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11347 }
11348 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11349 {
11350 arg2 = wxString_in_helper(obj1);
11351 if (arg2 == NULL) SWIG_fail;
11352 temp2 = true;
11353 }
11354 {
11355 PyThreadState* __tstate = wxPyBeginAllowThreads();
11356 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11357 wxPyEndAllowThreads(__tstate);
11358 if (PyErr_Occurred()) SWIG_fail;
11359 }
11360 {
11361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11362 }
11363 {
11364 if (temp2)
11365 delete arg2;
11366 }
11367 return resultobj;
11368 fail:
11369 {
11370 if (temp2)
11371 delete arg2;
11372 }
11373 return NULL;
11374 }
11375
11376
11377 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11378 PyObject *resultobj = 0;
11379 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11380 wxFileSystem *arg2 = 0 ;
11381 wxString *arg3 = 0 ;
11382 wxFSFile *result = 0 ;
11383 void *argp1 = 0 ;
11384 int res1 = 0 ;
11385 void *argp2 = 0 ;
11386 int res2 = 0 ;
11387 bool temp3 = false ;
11388 PyObject * obj0 = 0 ;
11389 PyObject * obj1 = 0 ;
11390 PyObject * obj2 = 0 ;
11391 char * kwnames[] = {
11392 (char *) "self",(char *) "fs",(char *) "location", NULL
11393 };
11394
11395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11397 if (!SWIG_IsOK(res1)) {
11398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11399 }
11400 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11401 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11402 if (!SWIG_IsOK(res2)) {
11403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11404 }
11405 if (!argp2) {
11406 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11407 }
11408 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11409 {
11410 arg3 = wxString_in_helper(obj2);
11411 if (arg3 == NULL) SWIG_fail;
11412 temp3 = true;
11413 }
11414 {
11415 PyThreadState* __tstate = wxPyBeginAllowThreads();
11416 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11417 wxPyEndAllowThreads(__tstate);
11418 if (PyErr_Occurred()) SWIG_fail;
11419 }
11420 {
11421 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11422 }
11423 {
11424 if (temp3)
11425 delete arg3;
11426 }
11427 return resultobj;
11428 fail:
11429 {
11430 if (temp3)
11431 delete arg3;
11432 }
11433 return NULL;
11434 }
11435
11436
11437 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11438 PyObject *obj;
11439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11440 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11441 return SWIG_Py_Void();
11442 }
11443
11444 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11445 return SWIG_Python_InitShadowInstance(args);
11446 }
11447
11448 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11449 PyObject *resultobj = 0;
11450 wxZipFSHandler *result = 0 ;
11451
11452 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11453 {
11454 PyThreadState* __tstate = wxPyBeginAllowThreads();
11455 result = (wxZipFSHandler *)new wxZipFSHandler();
11456 wxPyEndAllowThreads(__tstate);
11457 if (PyErr_Occurred()) SWIG_fail;
11458 }
11459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11460 return resultobj;
11461 fail:
11462 return NULL;
11463 }
11464
11465
11466 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11467 PyObject *resultobj = 0;
11468 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11469 wxString *arg2 = 0 ;
11470 bool result;
11471 void *argp1 = 0 ;
11472 int res1 = 0 ;
11473 bool temp2 = false ;
11474 PyObject * obj0 = 0 ;
11475 PyObject * obj1 = 0 ;
11476 char * kwnames[] = {
11477 (char *) "self",(char *) "location", NULL
11478 };
11479
11480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11482 if (!SWIG_IsOK(res1)) {
11483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11484 }
11485 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11486 {
11487 arg2 = wxString_in_helper(obj1);
11488 if (arg2 == NULL) SWIG_fail;
11489 temp2 = true;
11490 }
11491 {
11492 PyThreadState* __tstate = wxPyBeginAllowThreads();
11493 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11494 wxPyEndAllowThreads(__tstate);
11495 if (PyErr_Occurred()) SWIG_fail;
11496 }
11497 {
11498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11499 }
11500 {
11501 if (temp2)
11502 delete arg2;
11503 }
11504 return resultobj;
11505 fail:
11506 {
11507 if (temp2)
11508 delete arg2;
11509 }
11510 return NULL;
11511 }
11512
11513
11514 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11515 PyObject *resultobj = 0;
11516 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11517 wxFileSystem *arg2 = 0 ;
11518 wxString *arg3 = 0 ;
11519 wxFSFile *result = 0 ;
11520 void *argp1 = 0 ;
11521 int res1 = 0 ;
11522 void *argp2 = 0 ;
11523 int res2 = 0 ;
11524 bool temp3 = false ;
11525 PyObject * obj0 = 0 ;
11526 PyObject * obj1 = 0 ;
11527 PyObject * obj2 = 0 ;
11528 char * kwnames[] = {
11529 (char *) "self",(char *) "fs",(char *) "location", NULL
11530 };
11531
11532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11534 if (!SWIG_IsOK(res1)) {
11535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11536 }
11537 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11539 if (!SWIG_IsOK(res2)) {
11540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11541 }
11542 if (!argp2) {
11543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11544 }
11545 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11546 {
11547 arg3 = wxString_in_helper(obj2);
11548 if (arg3 == NULL) SWIG_fail;
11549 temp3 = true;
11550 }
11551 {
11552 PyThreadState* __tstate = wxPyBeginAllowThreads();
11553 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11554 wxPyEndAllowThreads(__tstate);
11555 if (PyErr_Occurred()) SWIG_fail;
11556 }
11557 {
11558 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11559 }
11560 {
11561 if (temp3)
11562 delete arg3;
11563 }
11564 return resultobj;
11565 fail:
11566 {
11567 if (temp3)
11568 delete arg3;
11569 }
11570 return NULL;
11571 }
11572
11573
11574 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11575 PyObject *resultobj = 0;
11576 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11577 wxString *arg2 = 0 ;
11578 int arg3 = (int) 0 ;
11579 wxString result;
11580 void *argp1 = 0 ;
11581 int res1 = 0 ;
11582 bool temp2 = false ;
11583 int val3 ;
11584 int ecode3 = 0 ;
11585 PyObject * obj0 = 0 ;
11586 PyObject * obj1 = 0 ;
11587 PyObject * obj2 = 0 ;
11588 char * kwnames[] = {
11589 (char *) "self",(char *) "spec",(char *) "flags", NULL
11590 };
11591
11592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11594 if (!SWIG_IsOK(res1)) {
11595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11596 }
11597 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11598 {
11599 arg2 = wxString_in_helper(obj1);
11600 if (arg2 == NULL) SWIG_fail;
11601 temp2 = true;
11602 }
11603 if (obj2) {
11604 ecode3 = SWIG_AsVal_int(obj2, &val3);
11605 if (!SWIG_IsOK(ecode3)) {
11606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11607 }
11608 arg3 = static_cast< int >(val3);
11609 }
11610 {
11611 PyThreadState* __tstate = wxPyBeginAllowThreads();
11612 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11613 wxPyEndAllowThreads(__tstate);
11614 if (PyErr_Occurred()) SWIG_fail;
11615 }
11616 {
11617 #if wxUSE_UNICODE
11618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11619 #else
11620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11621 #endif
11622 }
11623 {
11624 if (temp2)
11625 delete arg2;
11626 }
11627 return resultobj;
11628 fail:
11629 {
11630 if (temp2)
11631 delete arg2;
11632 }
11633 return NULL;
11634 }
11635
11636
11637 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11638 PyObject *resultobj = 0;
11639 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11640 wxString result;
11641 void *argp1 = 0 ;
11642 int res1 = 0 ;
11643 PyObject *swig_obj[1] ;
11644
11645 if (!args) SWIG_fail;
11646 swig_obj[0] = args;
11647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11648 if (!SWIG_IsOK(res1)) {
11649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11650 }
11651 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11652 {
11653 PyThreadState* __tstate = wxPyBeginAllowThreads();
11654 result = (arg1)->FindNext();
11655 wxPyEndAllowThreads(__tstate);
11656 if (PyErr_Occurred()) SWIG_fail;
11657 }
11658 {
11659 #if wxUSE_UNICODE
11660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11661 #else
11662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11663 #endif
11664 }
11665 return resultobj;
11666 fail:
11667 return NULL;
11668 }
11669
11670
11671 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11672 PyObject *obj;
11673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11674 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11675 return SWIG_Py_Void();
11676 }
11677
11678 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11679 return SWIG_Python_InitShadowInstance(args);
11680 }
11681
11682 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11683 PyObject *resultobj = 0;
11684 wxString *arg1 = 0 ;
11685 wxImage *arg2 = 0 ;
11686 long arg3 ;
11687 bool temp1 = false ;
11688 void *argp2 = 0 ;
11689 int res2 = 0 ;
11690 long val3 ;
11691 int ecode3 = 0 ;
11692 PyObject * obj0 = 0 ;
11693 PyObject * obj1 = 0 ;
11694 PyObject * obj2 = 0 ;
11695 char * kwnames[] = {
11696 (char *) "filename",(char *) "image",(char *) "type", NULL
11697 };
11698
11699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11700 {
11701 arg1 = wxString_in_helper(obj0);
11702 if (arg1 == NULL) SWIG_fail;
11703 temp1 = true;
11704 }
11705 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11706 if (!SWIG_IsOK(res2)) {
11707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11708 }
11709 if (!argp2) {
11710 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11711 }
11712 arg2 = reinterpret_cast< wxImage * >(argp2);
11713 ecode3 = SWIG_AsVal_long(obj2, &val3);
11714 if (!SWIG_IsOK(ecode3)) {
11715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11716 }
11717 arg3 = static_cast< long >(val3);
11718 {
11719 PyThreadState* __tstate = wxPyBeginAllowThreads();
11720 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11721 wxPyEndAllowThreads(__tstate);
11722 if (PyErr_Occurred()) SWIG_fail;
11723 }
11724 resultobj = SWIG_Py_Void();
11725 {
11726 if (temp1)
11727 delete arg1;
11728 }
11729 return resultobj;
11730 fail:
11731 {
11732 if (temp1)
11733 delete arg1;
11734 }
11735 return NULL;
11736 }
11737
11738
11739 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11740 PyObject *resultobj = 0;
11741 wxString *arg1 = 0 ;
11742 wxBitmap *arg2 = 0 ;
11743 long arg3 ;
11744 bool temp1 = false ;
11745 void *argp2 = 0 ;
11746 int res2 = 0 ;
11747 long val3 ;
11748 int ecode3 = 0 ;
11749 PyObject * obj0 = 0 ;
11750 PyObject * obj1 = 0 ;
11751 PyObject * obj2 = 0 ;
11752 char * kwnames[] = {
11753 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11754 };
11755
11756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11757 {
11758 arg1 = wxString_in_helper(obj0);
11759 if (arg1 == NULL) SWIG_fail;
11760 temp1 = true;
11761 }
11762 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11763 if (!SWIG_IsOK(res2)) {
11764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11765 }
11766 if (!argp2) {
11767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11768 }
11769 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11770 ecode3 = SWIG_AsVal_long(obj2, &val3);
11771 if (!SWIG_IsOK(ecode3)) {
11772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11773 }
11774 arg3 = static_cast< long >(val3);
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11778 wxPyEndAllowThreads(__tstate);
11779 if (PyErr_Occurred()) SWIG_fail;
11780 }
11781 resultobj = SWIG_Py_Void();
11782 {
11783 if (temp1)
11784 delete arg1;
11785 }
11786 return resultobj;
11787 fail:
11788 {
11789 if (temp1)
11790 delete arg1;
11791 }
11792 return NULL;
11793 }
11794
11795
11796 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11797 PyObject *resultobj = 0;
11798 wxString *arg1 = 0 ;
11799 PyObject *arg2 = (PyObject *) 0 ;
11800 bool temp1 = false ;
11801 PyObject * obj0 = 0 ;
11802 PyObject * obj1 = 0 ;
11803 char * kwnames[] = {
11804 (char *) "filename",(char *) "data", NULL
11805 };
11806
11807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11808 {
11809 arg1 = wxString_in_helper(obj0);
11810 if (arg1 == NULL) SWIG_fail;
11811 temp1 = true;
11812 }
11813 arg2 = obj1;
11814 {
11815 PyThreadState* __tstate = wxPyBeginAllowThreads();
11816 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11817 wxPyEndAllowThreads(__tstate);
11818 if (PyErr_Occurred()) SWIG_fail;
11819 }
11820 resultobj = SWIG_Py_Void();
11821 {
11822 if (temp1)
11823 delete arg1;
11824 }
11825 return resultobj;
11826 fail:
11827 {
11828 if (temp1)
11829 delete arg1;
11830 }
11831 return NULL;
11832 }
11833
11834
11835 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11836 PyObject *resultobj = 0;
11837 wxMemoryFSHandler *result = 0 ;
11838
11839 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11840 {
11841 PyThreadState* __tstate = wxPyBeginAllowThreads();
11842 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11843 wxPyEndAllowThreads(__tstate);
11844 if (PyErr_Occurred()) SWIG_fail;
11845 }
11846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11847 return resultobj;
11848 fail:
11849 return NULL;
11850 }
11851
11852
11853 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11854 PyObject *resultobj = 0;
11855 wxString *arg1 = 0 ;
11856 bool temp1 = false ;
11857 PyObject * obj0 = 0 ;
11858 char * kwnames[] = {
11859 (char *) "filename", NULL
11860 };
11861
11862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11863 {
11864 arg1 = wxString_in_helper(obj0);
11865 if (arg1 == NULL) SWIG_fail;
11866 temp1 = true;
11867 }
11868 {
11869 PyThreadState* __tstate = wxPyBeginAllowThreads();
11870 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11871 wxPyEndAllowThreads(__tstate);
11872 if (PyErr_Occurred()) SWIG_fail;
11873 }
11874 resultobj = SWIG_Py_Void();
11875 {
11876 if (temp1)
11877 delete arg1;
11878 }
11879 return resultobj;
11880 fail:
11881 {
11882 if (temp1)
11883 delete arg1;
11884 }
11885 return NULL;
11886 }
11887
11888
11889 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11890 PyObject *resultobj = 0;
11891 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11892 wxString *arg2 = 0 ;
11893 bool result;
11894 void *argp1 = 0 ;
11895 int res1 = 0 ;
11896 bool temp2 = false ;
11897 PyObject * obj0 = 0 ;
11898 PyObject * obj1 = 0 ;
11899 char * kwnames[] = {
11900 (char *) "self",(char *) "location", NULL
11901 };
11902
11903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11905 if (!SWIG_IsOK(res1)) {
11906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11907 }
11908 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11909 {
11910 arg2 = wxString_in_helper(obj1);
11911 if (arg2 == NULL) SWIG_fail;
11912 temp2 = true;
11913 }
11914 {
11915 PyThreadState* __tstate = wxPyBeginAllowThreads();
11916 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11917 wxPyEndAllowThreads(__tstate);
11918 if (PyErr_Occurred()) SWIG_fail;
11919 }
11920 {
11921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11922 }
11923 {
11924 if (temp2)
11925 delete arg2;
11926 }
11927 return resultobj;
11928 fail:
11929 {
11930 if (temp2)
11931 delete arg2;
11932 }
11933 return NULL;
11934 }
11935
11936
11937 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11938 PyObject *resultobj = 0;
11939 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11940 wxFileSystem *arg2 = 0 ;
11941 wxString *arg3 = 0 ;
11942 wxFSFile *result = 0 ;
11943 void *argp1 = 0 ;
11944 int res1 = 0 ;
11945 void *argp2 = 0 ;
11946 int res2 = 0 ;
11947 bool temp3 = false ;
11948 PyObject * obj0 = 0 ;
11949 PyObject * obj1 = 0 ;
11950 PyObject * obj2 = 0 ;
11951 char * kwnames[] = {
11952 (char *) "self",(char *) "fs",(char *) "location", NULL
11953 };
11954
11955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11957 if (!SWIG_IsOK(res1)) {
11958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11959 }
11960 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11962 if (!SWIG_IsOK(res2)) {
11963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11964 }
11965 if (!argp2) {
11966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11967 }
11968 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11969 {
11970 arg3 = wxString_in_helper(obj2);
11971 if (arg3 == NULL) SWIG_fail;
11972 temp3 = true;
11973 }
11974 {
11975 PyThreadState* __tstate = wxPyBeginAllowThreads();
11976 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11977 wxPyEndAllowThreads(__tstate);
11978 if (PyErr_Occurred()) SWIG_fail;
11979 }
11980 {
11981 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11982 }
11983 {
11984 if (temp3)
11985 delete arg3;
11986 }
11987 return resultobj;
11988 fail:
11989 {
11990 if (temp3)
11991 delete arg3;
11992 }
11993 return NULL;
11994 }
11995
11996
11997 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11998 PyObject *resultobj = 0;
11999 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
12000 wxString *arg2 = 0 ;
12001 int arg3 = (int) 0 ;
12002 wxString result;
12003 void *argp1 = 0 ;
12004 int res1 = 0 ;
12005 bool temp2 = false ;
12006 int val3 ;
12007 int ecode3 = 0 ;
12008 PyObject * obj0 = 0 ;
12009 PyObject * obj1 = 0 ;
12010 PyObject * obj2 = 0 ;
12011 char * kwnames[] = {
12012 (char *) "self",(char *) "spec",(char *) "flags", NULL
12013 };
12014
12015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12017 if (!SWIG_IsOK(res1)) {
12018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12019 }
12020 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12021 {
12022 arg2 = wxString_in_helper(obj1);
12023 if (arg2 == NULL) SWIG_fail;
12024 temp2 = true;
12025 }
12026 if (obj2) {
12027 ecode3 = SWIG_AsVal_int(obj2, &val3);
12028 if (!SWIG_IsOK(ecode3)) {
12029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12030 }
12031 arg3 = static_cast< int >(val3);
12032 }
12033 {
12034 PyThreadState* __tstate = wxPyBeginAllowThreads();
12035 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12036 wxPyEndAllowThreads(__tstate);
12037 if (PyErr_Occurred()) SWIG_fail;
12038 }
12039 {
12040 #if wxUSE_UNICODE
12041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12042 #else
12043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12044 #endif
12045 }
12046 {
12047 if (temp2)
12048 delete arg2;
12049 }
12050 return resultobj;
12051 fail:
12052 {
12053 if (temp2)
12054 delete arg2;
12055 }
12056 return NULL;
12057 }
12058
12059
12060 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12061 PyObject *resultobj = 0;
12062 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
12063 wxString result;
12064 void *argp1 = 0 ;
12065 int res1 = 0 ;
12066 PyObject *swig_obj[1] ;
12067
12068 if (!args) SWIG_fail;
12069 swig_obj[0] = args;
12070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12071 if (!SWIG_IsOK(res1)) {
12072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12073 }
12074 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12075 {
12076 PyThreadState* __tstate = wxPyBeginAllowThreads();
12077 result = (arg1)->FindNext();
12078 wxPyEndAllowThreads(__tstate);
12079 if (PyErr_Occurred()) SWIG_fail;
12080 }
12081 {
12082 #if wxUSE_UNICODE
12083 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12084 #else
12085 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12086 #endif
12087 }
12088 return resultobj;
12089 fail:
12090 return NULL;
12091 }
12092
12093
12094 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12095 PyObject *obj;
12096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12097 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
12098 return SWIG_Py_Void();
12099 }
12100
12101 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12102 return SWIG_Python_InitShadowInstance(args);
12103 }
12104
12105 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12106 PyObject *resultobj = 0;
12107 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12108 wxString result;
12109 void *argp1 = 0 ;
12110 int res1 = 0 ;
12111 PyObject *swig_obj[1] ;
12112
12113 if (!args) SWIG_fail;
12114 swig_obj[0] = args;
12115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12116 if (!SWIG_IsOK(res1)) {
12117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12118 }
12119 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12120 {
12121 PyThreadState* __tstate = wxPyBeginAllowThreads();
12122 result = (arg1)->GetName();
12123 wxPyEndAllowThreads(__tstate);
12124 if (PyErr_Occurred()) SWIG_fail;
12125 }
12126 {
12127 #if wxUSE_UNICODE
12128 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12129 #else
12130 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12131 #endif
12132 }
12133 return resultobj;
12134 fail:
12135 return NULL;
12136 }
12137
12138
12139 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12140 PyObject *resultobj = 0;
12141 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12142 wxString result;
12143 void *argp1 = 0 ;
12144 int res1 = 0 ;
12145 PyObject *swig_obj[1] ;
12146
12147 if (!args) SWIG_fail;
12148 swig_obj[0] = args;
12149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12150 if (!SWIG_IsOK(res1)) {
12151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12152 }
12153 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12154 {
12155 PyThreadState* __tstate = wxPyBeginAllowThreads();
12156 result = (arg1)->GetExtension();
12157 wxPyEndAllowThreads(__tstate);
12158 if (PyErr_Occurred()) SWIG_fail;
12159 }
12160 {
12161 #if wxUSE_UNICODE
12162 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12163 #else
12164 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12165 #endif
12166 }
12167 return resultobj;
12168 fail:
12169 return NULL;
12170 }
12171
12172
12173 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12174 PyObject *resultobj = 0;
12175 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12176 long result;
12177 void *argp1 = 0 ;
12178 int res1 = 0 ;
12179 PyObject *swig_obj[1] ;
12180
12181 if (!args) SWIG_fail;
12182 swig_obj[0] = args;
12183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12184 if (!SWIG_IsOK(res1)) {
12185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12186 }
12187 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12188 {
12189 PyThreadState* __tstate = wxPyBeginAllowThreads();
12190 result = (long)(arg1)->GetType();
12191 wxPyEndAllowThreads(__tstate);
12192 if (PyErr_Occurred()) SWIG_fail;
12193 }
12194 resultobj = SWIG_From_long(static_cast< long >(result));
12195 return resultobj;
12196 fail:
12197 return NULL;
12198 }
12199
12200
12201 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12202 PyObject *resultobj = 0;
12203 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12204 wxString result;
12205 void *argp1 = 0 ;
12206 int res1 = 0 ;
12207 PyObject *swig_obj[1] ;
12208
12209 if (!args) SWIG_fail;
12210 swig_obj[0] = args;
12211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12212 if (!SWIG_IsOK(res1)) {
12213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12214 }
12215 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12216 {
12217 PyThreadState* __tstate = wxPyBeginAllowThreads();
12218 result = (arg1)->GetMimeType();
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 {
12223 #if wxUSE_UNICODE
12224 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12225 #else
12226 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12227 #endif
12228 }
12229 return resultobj;
12230 fail:
12231 return NULL;
12232 }
12233
12234
12235 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12236 PyObject *resultobj = 0;
12237 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12238 wxString *arg2 = 0 ;
12239 bool result;
12240 void *argp1 = 0 ;
12241 int res1 = 0 ;
12242 bool temp2 = false ;
12243 PyObject * obj0 = 0 ;
12244 PyObject * obj1 = 0 ;
12245 char * kwnames[] = {
12246 (char *) "self",(char *) "name", NULL
12247 };
12248
12249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12251 if (!SWIG_IsOK(res1)) {
12252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12253 }
12254 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12255 {
12256 arg2 = wxString_in_helper(obj1);
12257 if (arg2 == NULL) SWIG_fail;
12258 temp2 = true;
12259 }
12260 {
12261 PyThreadState* __tstate = wxPyBeginAllowThreads();
12262 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12263 wxPyEndAllowThreads(__tstate);
12264 if (PyErr_Occurred()) SWIG_fail;
12265 }
12266 {
12267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12268 }
12269 {
12270 if (temp2)
12271 delete arg2;
12272 }
12273 return resultobj;
12274 fail:
12275 {
12276 if (temp2)
12277 delete arg2;
12278 }
12279 return NULL;
12280 }
12281
12282
12283 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12284 PyObject *resultobj = 0;
12285 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12286 wxInputStream *arg2 = 0 ;
12287 bool result;
12288 void *argp1 = 0 ;
12289 int res1 = 0 ;
12290 wxPyInputStream *temp2 ;
12291 bool created2 ;
12292 PyObject * obj0 = 0 ;
12293 PyObject * obj1 = 0 ;
12294 char * kwnames[] = {
12295 (char *) "self",(char *) "stream", NULL
12296 };
12297
12298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12300 if (!SWIG_IsOK(res1)) {
12301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12302 }
12303 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12304 {
12305 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12306 arg2 = temp2->m_wxis;
12307 created2 = false;
12308 } else {
12309 PyErr_Clear(); // clear the failure of the wxPyConvert above
12310 arg2 = wxPyCBInputStream_create(obj1, false);
12311 if (arg2 == NULL) {
12312 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12313 SWIG_fail;
12314 }
12315 created2 = true;
12316 }
12317 }
12318 {
12319 PyThreadState* __tstate = wxPyBeginAllowThreads();
12320 result = (bool)(arg1)->CanRead(*arg2);
12321 wxPyEndAllowThreads(__tstate);
12322 if (PyErr_Occurred()) SWIG_fail;
12323 }
12324 {
12325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12326 }
12327 {
12328 if (created2) delete arg2;
12329 }
12330 return resultobj;
12331 fail:
12332 {
12333 if (created2) delete arg2;
12334 }
12335 return NULL;
12336 }
12337
12338
12339 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12340 PyObject *resultobj = 0;
12341 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12342 wxString *arg2 = 0 ;
12343 void *argp1 = 0 ;
12344 int res1 = 0 ;
12345 bool temp2 = false ;
12346 PyObject * obj0 = 0 ;
12347 PyObject * obj1 = 0 ;
12348 char * kwnames[] = {
12349 (char *) "self",(char *) "name", NULL
12350 };
12351
12352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12354 if (!SWIG_IsOK(res1)) {
12355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12356 }
12357 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12358 {
12359 arg2 = wxString_in_helper(obj1);
12360 if (arg2 == NULL) SWIG_fail;
12361 temp2 = true;
12362 }
12363 {
12364 PyThreadState* __tstate = wxPyBeginAllowThreads();
12365 (arg1)->SetName((wxString const &)*arg2);
12366 wxPyEndAllowThreads(__tstate);
12367 if (PyErr_Occurred()) SWIG_fail;
12368 }
12369 resultobj = SWIG_Py_Void();
12370 {
12371 if (temp2)
12372 delete arg2;
12373 }
12374 return resultobj;
12375 fail:
12376 {
12377 if (temp2)
12378 delete arg2;
12379 }
12380 return NULL;
12381 }
12382
12383
12384 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12385 PyObject *resultobj = 0;
12386 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12387 wxString *arg2 = 0 ;
12388 void *argp1 = 0 ;
12389 int res1 = 0 ;
12390 bool temp2 = false ;
12391 PyObject * obj0 = 0 ;
12392 PyObject * obj1 = 0 ;
12393 char * kwnames[] = {
12394 (char *) "self",(char *) "extension", NULL
12395 };
12396
12397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12399 if (!SWIG_IsOK(res1)) {
12400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12401 }
12402 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12403 {
12404 arg2 = wxString_in_helper(obj1);
12405 if (arg2 == NULL) SWIG_fail;
12406 temp2 = true;
12407 }
12408 {
12409 PyThreadState* __tstate = wxPyBeginAllowThreads();
12410 (arg1)->SetExtension((wxString const &)*arg2);
12411 wxPyEndAllowThreads(__tstate);
12412 if (PyErr_Occurred()) SWIG_fail;
12413 }
12414 resultobj = SWIG_Py_Void();
12415 {
12416 if (temp2)
12417 delete arg2;
12418 }
12419 return resultobj;
12420 fail:
12421 {
12422 if (temp2)
12423 delete arg2;
12424 }
12425 return NULL;
12426 }
12427
12428
12429 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12430 PyObject *resultobj = 0;
12431 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12432 long arg2 ;
12433 void *argp1 = 0 ;
12434 int res1 = 0 ;
12435 long val2 ;
12436 int ecode2 = 0 ;
12437 PyObject * obj0 = 0 ;
12438 PyObject * obj1 = 0 ;
12439 char * kwnames[] = {
12440 (char *) "self",(char *) "type", NULL
12441 };
12442
12443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12445 if (!SWIG_IsOK(res1)) {
12446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12447 }
12448 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12449 ecode2 = SWIG_AsVal_long(obj1, &val2);
12450 if (!SWIG_IsOK(ecode2)) {
12451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12452 }
12453 arg2 = static_cast< long >(val2);
12454 {
12455 PyThreadState* __tstate = wxPyBeginAllowThreads();
12456 (arg1)->SetType(arg2);
12457 wxPyEndAllowThreads(__tstate);
12458 if (PyErr_Occurred()) SWIG_fail;
12459 }
12460 resultobj = SWIG_Py_Void();
12461 return resultobj;
12462 fail:
12463 return NULL;
12464 }
12465
12466
12467 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12468 PyObject *resultobj = 0;
12469 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12470 wxString *arg2 = 0 ;
12471 void *argp1 = 0 ;
12472 int res1 = 0 ;
12473 bool temp2 = false ;
12474 PyObject * obj0 = 0 ;
12475 PyObject * obj1 = 0 ;
12476 char * kwnames[] = {
12477 (char *) "self",(char *) "mimetype", NULL
12478 };
12479
12480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12482 if (!SWIG_IsOK(res1)) {
12483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12484 }
12485 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12486 {
12487 arg2 = wxString_in_helper(obj1);
12488 if (arg2 == NULL) SWIG_fail;
12489 temp2 = true;
12490 }
12491 {
12492 PyThreadState* __tstate = wxPyBeginAllowThreads();
12493 (arg1)->SetMimeType((wxString const &)*arg2);
12494 wxPyEndAllowThreads(__tstate);
12495 if (PyErr_Occurred()) SWIG_fail;
12496 }
12497 resultobj = SWIG_Py_Void();
12498 {
12499 if (temp2)
12500 delete arg2;
12501 }
12502 return resultobj;
12503 fail:
12504 {
12505 if (temp2)
12506 delete arg2;
12507 }
12508 return NULL;
12509 }
12510
12511
12512 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12513 PyObject *obj;
12514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12515 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12516 return SWIG_Py_Void();
12517 }
12518
12519 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12520 PyObject *resultobj = 0;
12521 wxPyImageHandler *result = 0 ;
12522
12523 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12524 {
12525 PyThreadState* __tstate = wxPyBeginAllowThreads();
12526 result = (wxPyImageHandler *)new wxPyImageHandler();
12527 wxPyEndAllowThreads(__tstate);
12528 if (PyErr_Occurred()) SWIG_fail;
12529 }
12530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12531 return resultobj;
12532 fail:
12533 return NULL;
12534 }
12535
12536
12537 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12538 PyObject *resultobj = 0;
12539 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12540 PyObject *arg2 = (PyObject *) 0 ;
12541 void *argp1 = 0 ;
12542 int res1 = 0 ;
12543 PyObject * obj0 = 0 ;
12544 PyObject * obj1 = 0 ;
12545 char * kwnames[] = {
12546 (char *) "self",(char *) "self", NULL
12547 };
12548
12549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12551 if (!SWIG_IsOK(res1)) {
12552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12553 }
12554 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12555 arg2 = obj1;
12556 {
12557 PyThreadState* __tstate = wxPyBeginAllowThreads();
12558 (arg1)->_SetSelf(arg2);
12559 wxPyEndAllowThreads(__tstate);
12560 if (PyErr_Occurred()) SWIG_fail;
12561 }
12562 resultobj = SWIG_Py_Void();
12563 return resultobj;
12564 fail:
12565 return NULL;
12566 }
12567
12568
12569 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12570 PyObject *obj;
12571 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12572 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12573 return SWIG_Py_Void();
12574 }
12575
12576 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12577 return SWIG_Python_InitShadowInstance(args);
12578 }
12579
12580 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12581 PyObject *resultobj = 0;
12582 wxImageHistogram *result = 0 ;
12583
12584 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12585 {
12586 PyThreadState* __tstate = wxPyBeginAllowThreads();
12587 result = (wxImageHistogram *)new wxImageHistogram();
12588 wxPyEndAllowThreads(__tstate);
12589 if (PyErr_Occurred()) SWIG_fail;
12590 }
12591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12592 return resultobj;
12593 fail:
12594 return NULL;
12595 }
12596
12597
12598 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12599 PyObject *resultobj = 0;
12600 byte arg1 ;
12601 byte arg2 ;
12602 byte arg3 ;
12603 unsigned long result;
12604 unsigned char val1 ;
12605 int ecode1 = 0 ;
12606 unsigned char val2 ;
12607 int ecode2 = 0 ;
12608 unsigned char val3 ;
12609 int ecode3 = 0 ;
12610 PyObject * obj0 = 0 ;
12611 PyObject * obj1 = 0 ;
12612 PyObject * obj2 = 0 ;
12613 char * kwnames[] = {
12614 (char *) "r",(char *) "g",(char *) "b", NULL
12615 };
12616
12617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12618 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12619 if (!SWIG_IsOK(ecode1)) {
12620 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12621 }
12622 arg1 = static_cast< byte >(val1);
12623 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12624 if (!SWIG_IsOK(ecode2)) {
12625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12626 }
12627 arg2 = static_cast< byte >(val2);
12628 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12629 if (!SWIG_IsOK(ecode3)) {
12630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12631 }
12632 arg3 = static_cast< byte >(val3);
12633 {
12634 PyThreadState* __tstate = wxPyBeginAllowThreads();
12635 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12636 wxPyEndAllowThreads(__tstate);
12637 if (PyErr_Occurred()) SWIG_fail;
12638 }
12639 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12640 return resultobj;
12641 fail:
12642 return NULL;
12643 }
12644
12645
12646 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12647 PyObject *resultobj = 0;
12648 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12649 byte *arg2 = (byte *) 0 ;
12650 byte *arg3 = (byte *) 0 ;
12651 byte *arg4 = (byte *) 0 ;
12652 byte arg5 = (byte) 1 ;
12653 byte arg6 = (byte) 0 ;
12654 byte arg7 = (byte) 0 ;
12655 bool result;
12656 void *argp1 = 0 ;
12657 int res1 = 0 ;
12658 byte temp2 ;
12659 int res2 = SWIG_TMPOBJ ;
12660 byte temp3 ;
12661 int res3 = SWIG_TMPOBJ ;
12662 byte temp4 ;
12663 int res4 = SWIG_TMPOBJ ;
12664 unsigned char val5 ;
12665 int ecode5 = 0 ;
12666 unsigned char val6 ;
12667 int ecode6 = 0 ;
12668 unsigned char val7 ;
12669 int ecode7 = 0 ;
12670 PyObject * obj0 = 0 ;
12671 PyObject * obj1 = 0 ;
12672 PyObject * obj2 = 0 ;
12673 PyObject * obj3 = 0 ;
12674 char * kwnames[] = {
12675 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12676 };
12677
12678 arg2 = &temp2;
12679 arg3 = &temp3;
12680 arg4 = &temp4;
12681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12683 if (!SWIG_IsOK(res1)) {
12684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12685 }
12686 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12687 if (obj1) {
12688 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12689 if (!SWIG_IsOK(ecode5)) {
12690 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12691 }
12692 arg5 = static_cast< byte >(val5);
12693 }
12694 if (obj2) {
12695 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12696 if (!SWIG_IsOK(ecode6)) {
12697 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12698 }
12699 arg6 = static_cast< byte >(val6);
12700 }
12701 if (obj3) {
12702 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12703 if (!SWIG_IsOK(ecode7)) {
12704 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12705 }
12706 arg7 = static_cast< byte >(val7);
12707 }
12708 {
12709 PyThreadState* __tstate = wxPyBeginAllowThreads();
12710 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12711 wxPyEndAllowThreads(__tstate);
12712 if (PyErr_Occurred()) SWIG_fail;
12713 }
12714 {
12715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12716 }
12717 if (SWIG_IsTmpObj(res2)) {
12718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12719 } else {
12720 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12722 }
12723 if (SWIG_IsTmpObj(res3)) {
12724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12725 } else {
12726 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12727 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12728 }
12729 if (SWIG_IsTmpObj(res4)) {
12730 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12731 } else {
12732 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12734 }
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12742 PyObject *resultobj = 0;
12743 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12744 unsigned long arg2 ;
12745 unsigned long result;
12746 void *argp1 = 0 ;
12747 int res1 = 0 ;
12748 unsigned long val2 ;
12749 int ecode2 = 0 ;
12750 PyObject * obj0 = 0 ;
12751 PyObject * obj1 = 0 ;
12752 char * kwnames[] = {
12753 (char *) "self",(char *) "key", NULL
12754 };
12755
12756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12758 if (!SWIG_IsOK(res1)) {
12759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12760 }
12761 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12762 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12763 if (!SWIG_IsOK(ecode2)) {
12764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12765 }
12766 arg2 = static_cast< unsigned long >(val2);
12767 {
12768 PyThreadState* __tstate = wxPyBeginAllowThreads();
12769 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12770 wxPyEndAllowThreads(__tstate);
12771 if (PyErr_Occurred()) SWIG_fail;
12772 }
12773 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12774 return resultobj;
12775 fail:
12776 return NULL;
12777 }
12778
12779
12780 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12781 PyObject *resultobj = 0;
12782 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12783 byte arg2 ;
12784 byte arg3 ;
12785 byte arg4 ;
12786 unsigned long result;
12787 void *argp1 = 0 ;
12788 int res1 = 0 ;
12789 unsigned char val2 ;
12790 int ecode2 = 0 ;
12791 unsigned char val3 ;
12792 int ecode3 = 0 ;
12793 unsigned char val4 ;
12794 int ecode4 = 0 ;
12795 PyObject * obj0 = 0 ;
12796 PyObject * obj1 = 0 ;
12797 PyObject * obj2 = 0 ;
12798 PyObject * obj3 = 0 ;
12799 char * kwnames[] = {
12800 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12801 };
12802
12803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12805 if (!SWIG_IsOK(res1)) {
12806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12807 }
12808 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12809 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12810 if (!SWIG_IsOK(ecode2)) {
12811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12812 }
12813 arg2 = static_cast< byte >(val2);
12814 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12815 if (!SWIG_IsOK(ecode3)) {
12816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12817 }
12818 arg3 = static_cast< byte >(val3);
12819 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12820 if (!SWIG_IsOK(ecode4)) {
12821 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12822 }
12823 arg4 = static_cast< byte >(val4);
12824 {
12825 PyThreadState* __tstate = wxPyBeginAllowThreads();
12826 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12827 wxPyEndAllowThreads(__tstate);
12828 if (PyErr_Occurred()) SWIG_fail;
12829 }
12830 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12831 return resultobj;
12832 fail:
12833 return NULL;
12834 }
12835
12836
12837 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12838 PyObject *resultobj = 0;
12839 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12840 wxColour *arg2 = 0 ;
12841 unsigned long result;
12842 void *argp1 = 0 ;
12843 int res1 = 0 ;
12844 wxColour temp2 ;
12845 PyObject * obj0 = 0 ;
12846 PyObject * obj1 = 0 ;
12847 char * kwnames[] = {
12848 (char *) "self",(char *) "colour", NULL
12849 };
12850
12851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12853 if (!SWIG_IsOK(res1)) {
12854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12855 }
12856 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12857 {
12858 arg2 = &temp2;
12859 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12860 }
12861 {
12862 PyThreadState* __tstate = wxPyBeginAllowThreads();
12863 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12864 wxPyEndAllowThreads(__tstate);
12865 if (PyErr_Occurred()) SWIG_fail;
12866 }
12867 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12868 return resultobj;
12869 fail:
12870 return NULL;
12871 }
12872
12873
12874 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12875 PyObject *obj;
12876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12877 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12878 return SWIG_Py_Void();
12879 }
12880
12881 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12882 return SWIG_Python_InitShadowInstance(args);
12883 }
12884
12885 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12886 PyObject *resultobj = 0;
12887 byte arg1 = (byte) 0 ;
12888 byte arg2 = (byte) 0 ;
12889 byte arg3 = (byte) 0 ;
12890 wxImage_RGBValue *result = 0 ;
12891 unsigned char val1 ;
12892 int ecode1 = 0 ;
12893 unsigned char val2 ;
12894 int ecode2 = 0 ;
12895 unsigned char val3 ;
12896 int ecode3 = 0 ;
12897 PyObject * obj0 = 0 ;
12898 PyObject * obj1 = 0 ;
12899 PyObject * obj2 = 0 ;
12900 char * kwnames[] = {
12901 (char *) "r",(char *) "g",(char *) "b", NULL
12902 };
12903
12904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12905 if (obj0) {
12906 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12907 if (!SWIG_IsOK(ecode1)) {
12908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12909 }
12910 arg1 = static_cast< byte >(val1);
12911 }
12912 if (obj1) {
12913 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12914 if (!SWIG_IsOK(ecode2)) {
12915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12916 }
12917 arg2 = static_cast< byte >(val2);
12918 }
12919 if (obj2) {
12920 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12921 if (!SWIG_IsOK(ecode3)) {
12922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12923 }
12924 arg3 = static_cast< byte >(val3);
12925 }
12926 {
12927 PyThreadState* __tstate = wxPyBeginAllowThreads();
12928 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12929 wxPyEndAllowThreads(__tstate);
12930 if (PyErr_Occurred()) SWIG_fail;
12931 }
12932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12933 return resultobj;
12934 fail:
12935 return NULL;
12936 }
12937
12938
12939 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12940 PyObject *resultobj = 0;
12941 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12942 byte arg2 ;
12943 void *argp1 = 0 ;
12944 int res1 = 0 ;
12945 unsigned char val2 ;
12946 int ecode2 = 0 ;
12947 PyObject *swig_obj[2] ;
12948
12949 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12951 if (!SWIG_IsOK(res1)) {
12952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12953 }
12954 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12955 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12956 if (!SWIG_IsOK(ecode2)) {
12957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12958 }
12959 arg2 = static_cast< byte >(val2);
12960 if (arg1) (arg1)->red = arg2;
12961
12962 resultobj = SWIG_Py_Void();
12963 return resultobj;
12964 fail:
12965 return NULL;
12966 }
12967
12968
12969 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12970 PyObject *resultobj = 0;
12971 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12972 byte result;
12973 void *argp1 = 0 ;
12974 int res1 = 0 ;
12975 PyObject *swig_obj[1] ;
12976
12977 if (!args) SWIG_fail;
12978 swig_obj[0] = args;
12979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12980 if (!SWIG_IsOK(res1)) {
12981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12982 }
12983 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12984 result = (byte) ((arg1)->red);
12985 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12986 return resultobj;
12987 fail:
12988 return NULL;
12989 }
12990
12991
12992 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12993 PyObject *resultobj = 0;
12994 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12995 byte arg2 ;
12996 void *argp1 = 0 ;
12997 int res1 = 0 ;
12998 unsigned char val2 ;
12999 int ecode2 = 0 ;
13000 PyObject *swig_obj[2] ;
13001
13002 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
13003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13004 if (!SWIG_IsOK(res1)) {
13005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13006 }
13007 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13008 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13009 if (!SWIG_IsOK(ecode2)) {
13010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
13011 }
13012 arg2 = static_cast< byte >(val2);
13013 if (arg1) (arg1)->green = arg2;
13014
13015 resultobj = SWIG_Py_Void();
13016 return resultobj;
13017 fail:
13018 return NULL;
13019 }
13020
13021
13022 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13023 PyObject *resultobj = 0;
13024 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13025 byte result;
13026 void *argp1 = 0 ;
13027 int res1 = 0 ;
13028 PyObject *swig_obj[1] ;
13029
13030 if (!args) SWIG_fail;
13031 swig_obj[0] = args;
13032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13033 if (!SWIG_IsOK(res1)) {
13034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13035 }
13036 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13037 result = (byte) ((arg1)->green);
13038 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13039 return resultobj;
13040 fail:
13041 return NULL;
13042 }
13043
13044
13045 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13046 PyObject *resultobj = 0;
13047 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13048 byte arg2 ;
13049 void *argp1 = 0 ;
13050 int res1 = 0 ;
13051 unsigned char val2 ;
13052 int ecode2 = 0 ;
13053 PyObject *swig_obj[2] ;
13054
13055 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
13056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13057 if (!SWIG_IsOK(res1)) {
13058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13059 }
13060 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13061 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13062 if (!SWIG_IsOK(ecode2)) {
13063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
13064 }
13065 arg2 = static_cast< byte >(val2);
13066 if (arg1) (arg1)->blue = arg2;
13067
13068 resultobj = SWIG_Py_Void();
13069 return resultobj;
13070 fail:
13071 return NULL;
13072 }
13073
13074
13075 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13076 PyObject *resultobj = 0;
13077 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13078 byte result;
13079 void *argp1 = 0 ;
13080 int res1 = 0 ;
13081 PyObject *swig_obj[1] ;
13082
13083 if (!args) SWIG_fail;
13084 swig_obj[0] = args;
13085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13086 if (!SWIG_IsOK(res1)) {
13087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13088 }
13089 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13090 result = (byte) ((arg1)->blue);
13091 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13092 return resultobj;
13093 fail:
13094 return NULL;
13095 }
13096
13097
13098 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13099 PyObject *obj;
13100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13101 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
13102 return SWIG_Py_Void();
13103 }
13104
13105 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13106 return SWIG_Python_InitShadowInstance(args);
13107 }
13108
13109 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13110 PyObject *resultobj = 0;
13111 double arg1 = (double) 0.0 ;
13112 double arg2 = (double) 0.0 ;
13113 double arg3 = (double) 0.0 ;
13114 wxImage_HSVValue *result = 0 ;
13115 double val1 ;
13116 int ecode1 = 0 ;
13117 double val2 ;
13118 int ecode2 = 0 ;
13119 double val3 ;
13120 int ecode3 = 0 ;
13121 PyObject * obj0 = 0 ;
13122 PyObject * obj1 = 0 ;
13123 PyObject * obj2 = 0 ;
13124 char * kwnames[] = {
13125 (char *) "h",(char *) "s",(char *) "v", NULL
13126 };
13127
13128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13129 if (obj0) {
13130 ecode1 = SWIG_AsVal_double(obj0, &val1);
13131 if (!SWIG_IsOK(ecode1)) {
13132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
13133 }
13134 arg1 = static_cast< double >(val1);
13135 }
13136 if (obj1) {
13137 ecode2 = SWIG_AsVal_double(obj1, &val2);
13138 if (!SWIG_IsOK(ecode2)) {
13139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
13140 }
13141 arg2 = static_cast< double >(val2);
13142 }
13143 if (obj2) {
13144 ecode3 = SWIG_AsVal_double(obj2, &val3);
13145 if (!SWIG_IsOK(ecode3)) {
13146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
13147 }
13148 arg3 = static_cast< double >(val3);
13149 }
13150 {
13151 PyThreadState* __tstate = wxPyBeginAllowThreads();
13152 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
13153 wxPyEndAllowThreads(__tstate);
13154 if (PyErr_Occurred()) SWIG_fail;
13155 }
13156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
13157 return resultobj;
13158 fail:
13159 return NULL;
13160 }
13161
13162
13163 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13164 PyObject *resultobj = 0;
13165 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13166 double arg2 ;
13167 void *argp1 = 0 ;
13168 int res1 = 0 ;
13169 double val2 ;
13170 int ecode2 = 0 ;
13171 PyObject *swig_obj[2] ;
13172
13173 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
13174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13175 if (!SWIG_IsOK(res1)) {
13176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13177 }
13178 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13179 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13180 if (!SWIG_IsOK(ecode2)) {
13181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
13182 }
13183 arg2 = static_cast< double >(val2);
13184 if (arg1) (arg1)->hue = arg2;
13185
13186 resultobj = SWIG_Py_Void();
13187 return resultobj;
13188 fail:
13189 return NULL;
13190 }
13191
13192
13193 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13194 PyObject *resultobj = 0;
13195 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13196 double result;
13197 void *argp1 = 0 ;
13198 int res1 = 0 ;
13199 PyObject *swig_obj[1] ;
13200
13201 if (!args) SWIG_fail;
13202 swig_obj[0] = args;
13203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13204 if (!SWIG_IsOK(res1)) {
13205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13206 }
13207 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13208 result = (double) ((arg1)->hue);
13209 resultobj = SWIG_From_double(static_cast< double >(result));
13210 return resultobj;
13211 fail:
13212 return NULL;
13213 }
13214
13215
13216 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13217 PyObject *resultobj = 0;
13218 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13219 double arg2 ;
13220 void *argp1 = 0 ;
13221 int res1 = 0 ;
13222 double val2 ;
13223 int ecode2 = 0 ;
13224 PyObject *swig_obj[2] ;
13225
13226 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
13227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13228 if (!SWIG_IsOK(res1)) {
13229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13230 }
13231 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13232 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13233 if (!SWIG_IsOK(ecode2)) {
13234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
13235 }
13236 arg2 = static_cast< double >(val2);
13237 if (arg1) (arg1)->saturation = arg2;
13238
13239 resultobj = SWIG_Py_Void();
13240 return resultobj;
13241 fail:
13242 return NULL;
13243 }
13244
13245
13246 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13247 PyObject *resultobj = 0;
13248 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13249 double result;
13250 void *argp1 = 0 ;
13251 int res1 = 0 ;
13252 PyObject *swig_obj[1] ;
13253
13254 if (!args) SWIG_fail;
13255 swig_obj[0] = args;
13256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13257 if (!SWIG_IsOK(res1)) {
13258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13259 }
13260 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13261 result = (double) ((arg1)->saturation);
13262 resultobj = SWIG_From_double(static_cast< double >(result));
13263 return resultobj;
13264 fail:
13265 return NULL;
13266 }
13267
13268
13269 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13270 PyObject *resultobj = 0;
13271 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13272 double arg2 ;
13273 void *argp1 = 0 ;
13274 int res1 = 0 ;
13275 double val2 ;
13276 int ecode2 = 0 ;
13277 PyObject *swig_obj[2] ;
13278
13279 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13281 if (!SWIG_IsOK(res1)) {
13282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13283 }
13284 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13285 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13286 if (!SWIG_IsOK(ecode2)) {
13287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13288 }
13289 arg2 = static_cast< double >(val2);
13290 if (arg1) (arg1)->value = arg2;
13291
13292 resultobj = SWIG_Py_Void();
13293 return resultobj;
13294 fail:
13295 return NULL;
13296 }
13297
13298
13299 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13300 PyObject *resultobj = 0;
13301 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13302 double result;
13303 void *argp1 = 0 ;
13304 int res1 = 0 ;
13305 PyObject *swig_obj[1] ;
13306
13307 if (!args) SWIG_fail;
13308 swig_obj[0] = args;
13309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13310 if (!SWIG_IsOK(res1)) {
13311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13312 }
13313 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13314 result = (double) ((arg1)->value);
13315 resultobj = SWIG_From_double(static_cast< double >(result));
13316 return resultobj;
13317 fail:
13318 return NULL;
13319 }
13320
13321
13322 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13323 PyObject *obj;
13324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13325 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13326 return SWIG_Py_Void();
13327 }
13328
13329 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13330 return SWIG_Python_InitShadowInstance(args);
13331 }
13332
13333 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13334 PyObject *resultobj = 0;
13335 wxString *arg1 = 0 ;
13336 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13337 int arg3 = (int) -1 ;
13338 wxImage *result = 0 ;
13339 bool temp1 = false ;
13340 long val2 ;
13341 int ecode2 = 0 ;
13342 int val3 ;
13343 int ecode3 = 0 ;
13344 PyObject * obj0 = 0 ;
13345 PyObject * obj1 = 0 ;
13346 PyObject * obj2 = 0 ;
13347 char * kwnames[] = {
13348 (char *) "name",(char *) "type",(char *) "index", NULL
13349 };
13350
13351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13352 {
13353 arg1 = wxString_in_helper(obj0);
13354 if (arg1 == NULL) SWIG_fail;
13355 temp1 = true;
13356 }
13357 if (obj1) {
13358 ecode2 = SWIG_AsVal_long(obj1, &val2);
13359 if (!SWIG_IsOK(ecode2)) {
13360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13361 }
13362 arg2 = static_cast< long >(val2);
13363 }
13364 if (obj2) {
13365 ecode3 = SWIG_AsVal_int(obj2, &val3);
13366 if (!SWIG_IsOK(ecode3)) {
13367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13368 }
13369 arg3 = static_cast< int >(val3);
13370 }
13371 {
13372 PyThreadState* __tstate = wxPyBeginAllowThreads();
13373 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13374 wxPyEndAllowThreads(__tstate);
13375 if (PyErr_Occurred()) SWIG_fail;
13376 }
13377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13378 {
13379 if (temp1)
13380 delete arg1;
13381 }
13382 return resultobj;
13383 fail:
13384 {
13385 if (temp1)
13386 delete arg1;
13387 }
13388 return NULL;
13389 }
13390
13391
13392 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13393 PyObject *resultobj = 0;
13394 wxImage *arg1 = (wxImage *) 0 ;
13395 void *argp1 = 0 ;
13396 int res1 = 0 ;
13397 PyObject *swig_obj[1] ;
13398
13399 if (!args) SWIG_fail;
13400 swig_obj[0] = args;
13401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13402 if (!SWIG_IsOK(res1)) {
13403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13404 }
13405 arg1 = reinterpret_cast< wxImage * >(argp1);
13406 {
13407 PyThreadState* __tstate = wxPyBeginAllowThreads();
13408 delete arg1;
13409
13410 wxPyEndAllowThreads(__tstate);
13411 if (PyErr_Occurred()) SWIG_fail;
13412 }
13413 resultobj = SWIG_Py_Void();
13414 return resultobj;
13415 fail:
13416 return NULL;
13417 }
13418
13419
13420 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13421 PyObject *resultobj = 0;
13422 wxString *arg1 = 0 ;
13423 wxString *arg2 = 0 ;
13424 int arg3 = (int) -1 ;
13425 wxImage *result = 0 ;
13426 bool temp1 = false ;
13427 bool temp2 = false ;
13428 int val3 ;
13429 int ecode3 = 0 ;
13430 PyObject * obj0 = 0 ;
13431 PyObject * obj1 = 0 ;
13432 PyObject * obj2 = 0 ;
13433 char * kwnames[] = {
13434 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13435 };
13436
13437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13438 {
13439 arg1 = wxString_in_helper(obj0);
13440 if (arg1 == NULL) SWIG_fail;
13441 temp1 = true;
13442 }
13443 {
13444 arg2 = wxString_in_helper(obj1);
13445 if (arg2 == NULL) SWIG_fail;
13446 temp2 = true;
13447 }
13448 if (obj2) {
13449 ecode3 = SWIG_AsVal_int(obj2, &val3);
13450 if (!SWIG_IsOK(ecode3)) {
13451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13452 }
13453 arg3 = static_cast< int >(val3);
13454 }
13455 {
13456 PyThreadState* __tstate = wxPyBeginAllowThreads();
13457 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13458 wxPyEndAllowThreads(__tstate);
13459 if (PyErr_Occurred()) SWIG_fail;
13460 }
13461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13462 {
13463 if (temp1)
13464 delete arg1;
13465 }
13466 {
13467 if (temp2)
13468 delete arg2;
13469 }
13470 return resultobj;
13471 fail:
13472 {
13473 if (temp1)
13474 delete arg1;
13475 }
13476 {
13477 if (temp2)
13478 delete arg2;
13479 }
13480 return NULL;
13481 }
13482
13483
13484 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13485 PyObject *resultobj = 0;
13486 wxInputStream *arg1 = 0 ;
13487 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13488 int arg3 = (int) -1 ;
13489 wxImage *result = 0 ;
13490 wxPyInputStream *temp1 ;
13491 bool created1 ;
13492 long val2 ;
13493 int ecode2 = 0 ;
13494 int val3 ;
13495 int ecode3 = 0 ;
13496 PyObject * obj0 = 0 ;
13497 PyObject * obj1 = 0 ;
13498 PyObject * obj2 = 0 ;
13499 char * kwnames[] = {
13500 (char *) "stream",(char *) "type",(char *) "index", NULL
13501 };
13502
13503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13504 {
13505 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13506 arg1 = temp1->m_wxis;
13507 created1 = false;
13508 } else {
13509 PyErr_Clear(); // clear the failure of the wxPyConvert above
13510 arg1 = wxPyCBInputStream_create(obj0, false);
13511 if (arg1 == NULL) {
13512 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13513 SWIG_fail;
13514 }
13515 created1 = true;
13516 }
13517 }
13518 if (obj1) {
13519 ecode2 = SWIG_AsVal_long(obj1, &val2);
13520 if (!SWIG_IsOK(ecode2)) {
13521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13522 }
13523 arg2 = static_cast< long >(val2);
13524 }
13525 if (obj2) {
13526 ecode3 = SWIG_AsVal_int(obj2, &val3);
13527 if (!SWIG_IsOK(ecode3)) {
13528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13529 }
13530 arg3 = static_cast< int >(val3);
13531 }
13532 {
13533 PyThreadState* __tstate = wxPyBeginAllowThreads();
13534 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13535 wxPyEndAllowThreads(__tstate);
13536 if (PyErr_Occurred()) SWIG_fail;
13537 }
13538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13539 {
13540 if (created1) delete arg1;
13541 }
13542 return resultobj;
13543 fail:
13544 {
13545 if (created1) delete arg1;
13546 }
13547 return NULL;
13548 }
13549
13550
13551 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13552 PyObject *resultobj = 0;
13553 wxInputStream *arg1 = 0 ;
13554 wxString *arg2 = 0 ;
13555 int arg3 = (int) -1 ;
13556 wxImage *result = 0 ;
13557 wxPyInputStream *temp1 ;
13558 bool created1 ;
13559 bool temp2 = false ;
13560 int val3 ;
13561 int ecode3 = 0 ;
13562 PyObject * obj0 = 0 ;
13563 PyObject * obj1 = 0 ;
13564 PyObject * obj2 = 0 ;
13565 char * kwnames[] = {
13566 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13567 };
13568
13569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13570 {
13571 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13572 arg1 = temp1->m_wxis;
13573 created1 = false;
13574 } else {
13575 PyErr_Clear(); // clear the failure of the wxPyConvert above
13576 arg1 = wxPyCBInputStream_create(obj0, false);
13577 if (arg1 == NULL) {
13578 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13579 SWIG_fail;
13580 }
13581 created1 = true;
13582 }
13583 }
13584 {
13585 arg2 = wxString_in_helper(obj1);
13586 if (arg2 == NULL) SWIG_fail;
13587 temp2 = true;
13588 }
13589 if (obj2) {
13590 ecode3 = SWIG_AsVal_int(obj2, &val3);
13591 if (!SWIG_IsOK(ecode3)) {
13592 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13593 }
13594 arg3 = static_cast< int >(val3);
13595 }
13596 {
13597 PyThreadState* __tstate = wxPyBeginAllowThreads();
13598 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13599 wxPyEndAllowThreads(__tstate);
13600 if (PyErr_Occurred()) SWIG_fail;
13601 }
13602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13603 {
13604 if (created1) delete arg1;
13605 }
13606 {
13607 if (temp2)
13608 delete arg2;
13609 }
13610 return resultobj;
13611 fail:
13612 {
13613 if (created1) delete arg1;
13614 }
13615 {
13616 if (temp2)
13617 delete arg2;
13618 }
13619 return NULL;
13620 }
13621
13622
13623 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13624 PyObject *resultobj = 0;
13625 int arg1 = (int) 0 ;
13626 int arg2 = (int) 0 ;
13627 bool arg3 = (bool) true ;
13628 wxImage *result = 0 ;
13629 int val1 ;
13630 int ecode1 = 0 ;
13631 int val2 ;
13632 int ecode2 = 0 ;
13633 bool val3 ;
13634 int ecode3 = 0 ;
13635 PyObject * obj0 = 0 ;
13636 PyObject * obj1 = 0 ;
13637 PyObject * obj2 = 0 ;
13638 char * kwnames[] = {
13639 (char *) "width",(char *) "height",(char *) "clear", NULL
13640 };
13641
13642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13643 if (obj0) {
13644 ecode1 = SWIG_AsVal_int(obj0, &val1);
13645 if (!SWIG_IsOK(ecode1)) {
13646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13647 }
13648 arg1 = static_cast< int >(val1);
13649 }
13650 if (obj1) {
13651 ecode2 = SWIG_AsVal_int(obj1, &val2);
13652 if (!SWIG_IsOK(ecode2)) {
13653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13654 }
13655 arg2 = static_cast< int >(val2);
13656 }
13657 if (obj2) {
13658 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13659 if (!SWIG_IsOK(ecode3)) {
13660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13661 }
13662 arg3 = static_cast< bool >(val3);
13663 }
13664 {
13665 PyThreadState* __tstate = wxPyBeginAllowThreads();
13666 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13667 wxPyEndAllowThreads(__tstate);
13668 if (PyErr_Occurred()) SWIG_fail;
13669 }
13670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13671 return resultobj;
13672 fail:
13673 return NULL;
13674 }
13675
13676
13677 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13678 PyObject *resultobj = 0;
13679 wxBitmap *arg1 = 0 ;
13680 wxImage *result = 0 ;
13681 void *argp1 = 0 ;
13682 int res1 = 0 ;
13683 PyObject * obj0 = 0 ;
13684 char * kwnames[] = {
13685 (char *) "bitmap", NULL
13686 };
13687
13688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13689 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13690 if (!SWIG_IsOK(res1)) {
13691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13692 }
13693 if (!argp1) {
13694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13695 }
13696 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13697 {
13698 if (!wxPyCheckForApp()) SWIG_fail;
13699 PyThreadState* __tstate = wxPyBeginAllowThreads();
13700 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13701 wxPyEndAllowThreads(__tstate);
13702 if (PyErr_Occurred()) SWIG_fail;
13703 }
13704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13705 return resultobj;
13706 fail:
13707 return NULL;
13708 }
13709
13710
13711 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13712 PyObject *resultobj = 0;
13713 int arg1 ;
13714 int arg2 ;
13715 buffer arg3 ;
13716 int arg4 ;
13717 wxImage *result = 0 ;
13718 int val1 ;
13719 int ecode1 = 0 ;
13720 int val2 ;
13721 int ecode2 = 0 ;
13722 Py_ssize_t temp3 ;
13723 PyObject * obj0 = 0 ;
13724 PyObject * obj1 = 0 ;
13725 PyObject * obj2 = 0 ;
13726 char * kwnames[] = {
13727 (char *) "width",(char *) "height",(char *) "data", NULL
13728 };
13729
13730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13731 ecode1 = SWIG_AsVal_int(obj0, &val1);
13732 if (!SWIG_IsOK(ecode1)) {
13733 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13734 }
13735 arg1 = static_cast< int >(val1);
13736 ecode2 = SWIG_AsVal_int(obj1, &val2);
13737 if (!SWIG_IsOK(ecode2)) {
13738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13739 }
13740 arg2 = static_cast< int >(val2);
13741 {
13742 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13743 arg4 = (int)temp3;
13744 }
13745 {
13746 PyThreadState* __tstate = wxPyBeginAllowThreads();
13747 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13748 wxPyEndAllowThreads(__tstate);
13749 if (PyErr_Occurred()) SWIG_fail;
13750 }
13751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13752 return resultobj;
13753 fail:
13754 return NULL;
13755 }
13756
13757
13758 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13759 PyObject *resultobj = 0;
13760 int arg1 ;
13761 int arg2 ;
13762 buffer arg3 ;
13763 int arg4 ;
13764 buffer arg5 ;
13765 int arg6 ;
13766 wxImage *result = 0 ;
13767 int val1 ;
13768 int ecode1 = 0 ;
13769 int val2 ;
13770 int ecode2 = 0 ;
13771 Py_ssize_t temp3 ;
13772 Py_ssize_t temp5 ;
13773 PyObject * obj0 = 0 ;
13774 PyObject * obj1 = 0 ;
13775 PyObject * obj2 = 0 ;
13776 PyObject * obj3 = 0 ;
13777 char * kwnames[] = {
13778 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13779 };
13780
13781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13782 ecode1 = SWIG_AsVal_int(obj0, &val1);
13783 if (!SWIG_IsOK(ecode1)) {
13784 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13785 }
13786 arg1 = static_cast< int >(val1);
13787 ecode2 = SWIG_AsVal_int(obj1, &val2);
13788 if (!SWIG_IsOK(ecode2)) {
13789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13790 }
13791 arg2 = static_cast< int >(val2);
13792 {
13793 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13794 arg4 = (int)temp3;
13795 }
13796 {
13797 if (obj3 != Py_None) {
13798 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13799 arg6 = (int)temp5;
13800 }
13801 }
13802 {
13803 PyThreadState* __tstate = wxPyBeginAllowThreads();
13804 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13805 wxPyEndAllowThreads(__tstate);
13806 if (PyErr_Occurred()) SWIG_fail;
13807 }
13808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13809 return resultobj;
13810 fail:
13811 return NULL;
13812 }
13813
13814
13815 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13816 PyObject *resultobj = 0;
13817 wxImage *arg1 = (wxImage *) 0 ;
13818 int arg2 ;
13819 int arg3 ;
13820 bool arg4 = (bool) true ;
13821 void *argp1 = 0 ;
13822 int res1 = 0 ;
13823 int val2 ;
13824 int ecode2 = 0 ;
13825 int val3 ;
13826 int ecode3 = 0 ;
13827 bool val4 ;
13828 int ecode4 = 0 ;
13829 PyObject * obj0 = 0 ;
13830 PyObject * obj1 = 0 ;
13831 PyObject * obj2 = 0 ;
13832 PyObject * obj3 = 0 ;
13833 char * kwnames[] = {
13834 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13835 };
13836
13837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13839 if (!SWIG_IsOK(res1)) {
13840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13841 }
13842 arg1 = reinterpret_cast< wxImage * >(argp1);
13843 ecode2 = SWIG_AsVal_int(obj1, &val2);
13844 if (!SWIG_IsOK(ecode2)) {
13845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13846 }
13847 arg2 = static_cast< int >(val2);
13848 ecode3 = SWIG_AsVal_int(obj2, &val3);
13849 if (!SWIG_IsOK(ecode3)) {
13850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13851 }
13852 arg3 = static_cast< int >(val3);
13853 if (obj3) {
13854 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13855 if (!SWIG_IsOK(ecode4)) {
13856 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13857 }
13858 arg4 = static_cast< bool >(val4);
13859 }
13860 {
13861 PyThreadState* __tstate = wxPyBeginAllowThreads();
13862 (arg1)->Create(arg2,arg3,arg4);
13863 wxPyEndAllowThreads(__tstate);
13864 if (PyErr_Occurred()) SWIG_fail;
13865 }
13866 resultobj = SWIG_Py_Void();
13867 return resultobj;
13868 fail:
13869 return NULL;
13870 }
13871
13872
13873 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13874 PyObject *resultobj = 0;
13875 wxImage *arg1 = (wxImage *) 0 ;
13876 void *argp1 = 0 ;
13877 int res1 = 0 ;
13878 PyObject *swig_obj[1] ;
13879
13880 if (!args) SWIG_fail;
13881 swig_obj[0] = args;
13882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13883 if (!SWIG_IsOK(res1)) {
13884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13885 }
13886 arg1 = reinterpret_cast< wxImage * >(argp1);
13887 {
13888 PyThreadState* __tstate = wxPyBeginAllowThreads();
13889 (arg1)->Destroy();
13890 wxPyEndAllowThreads(__tstate);
13891 if (PyErr_Occurred()) SWIG_fail;
13892 }
13893 resultobj = SWIG_Py_Void();
13894 return resultobj;
13895 fail:
13896 return NULL;
13897 }
13898
13899
13900 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13901 PyObject *resultobj = 0;
13902 wxImage *arg1 = (wxImage *) 0 ;
13903 int arg2 ;
13904 int arg3 ;
13905 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
13906 SwigValueWrapper<wxImage > result;
13907 void *argp1 = 0 ;
13908 int res1 = 0 ;
13909 int val2 ;
13910 int ecode2 = 0 ;
13911 int val3 ;
13912 int ecode3 = 0 ;
13913 int val4 ;
13914 int ecode4 = 0 ;
13915 PyObject * obj0 = 0 ;
13916 PyObject * obj1 = 0 ;
13917 PyObject * obj2 = 0 ;
13918 PyObject * obj3 = 0 ;
13919 char * kwnames[] = {
13920 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
13921 };
13922
13923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13925 if (!SWIG_IsOK(res1)) {
13926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13927 }
13928 arg1 = reinterpret_cast< wxImage * >(argp1);
13929 ecode2 = SWIG_AsVal_int(obj1, &val2);
13930 if (!SWIG_IsOK(ecode2)) {
13931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13932 }
13933 arg2 = static_cast< int >(val2);
13934 ecode3 = SWIG_AsVal_int(obj2, &val3);
13935 if (!SWIG_IsOK(ecode3)) {
13936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13937 }
13938 arg3 = static_cast< int >(val3);
13939 if (obj3) {
13940 ecode4 = SWIG_AsVal_int(obj3, &val4);
13941 if (!SWIG_IsOK(ecode4)) {
13942 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
13943 }
13944 arg4 = static_cast< int >(val4);
13945 }
13946 {
13947 PyThreadState* __tstate = wxPyBeginAllowThreads();
13948 result = (arg1)->Scale(arg2,arg3,arg4);
13949 wxPyEndAllowThreads(__tstate);
13950 if (PyErr_Occurred()) SWIG_fail;
13951 }
13952 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13953 return resultobj;
13954 fail:
13955 return NULL;
13956 }
13957
13958
13959 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13960 PyObject *resultobj = 0;
13961 wxImage *arg1 = (wxImage *) 0 ;
13962 int arg2 ;
13963 int arg3 ;
13964 SwigValueWrapper<wxImage > result;
13965 void *argp1 = 0 ;
13966 int res1 = 0 ;
13967 int val2 ;
13968 int ecode2 = 0 ;
13969 int val3 ;
13970 int ecode3 = 0 ;
13971 PyObject * obj0 = 0 ;
13972 PyObject * obj1 = 0 ;
13973 PyObject * obj2 = 0 ;
13974 char * kwnames[] = {
13975 (char *) "self",(char *) "width",(char *) "height", NULL
13976 };
13977
13978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13980 if (!SWIG_IsOK(res1)) {
13981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
13982 }
13983 arg1 = reinterpret_cast< wxImage * >(argp1);
13984 ecode2 = SWIG_AsVal_int(obj1, &val2);
13985 if (!SWIG_IsOK(ecode2)) {
13986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
13987 }
13988 arg2 = static_cast< int >(val2);
13989 ecode3 = SWIG_AsVal_int(obj2, &val3);
13990 if (!SWIG_IsOK(ecode3)) {
13991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
13992 }
13993 arg3 = static_cast< int >(val3);
13994 {
13995 PyThreadState* __tstate = wxPyBeginAllowThreads();
13996 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
13997 wxPyEndAllowThreads(__tstate);
13998 if (PyErr_Occurred()) SWIG_fail;
13999 }
14000 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14001 return resultobj;
14002 fail:
14003 return NULL;
14004 }
14005
14006
14007 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14008 PyObject *resultobj = 0;
14009 wxImage *arg1 = (wxImage *) 0 ;
14010 int arg2 ;
14011 int arg3 ;
14012 SwigValueWrapper<wxImage > result;
14013 void *argp1 = 0 ;
14014 int res1 = 0 ;
14015 int val2 ;
14016 int ecode2 = 0 ;
14017 int val3 ;
14018 int ecode3 = 0 ;
14019 PyObject * obj0 = 0 ;
14020 PyObject * obj1 = 0 ;
14021 PyObject * obj2 = 0 ;
14022 char * kwnames[] = {
14023 (char *) "self",(char *) "width",(char *) "height", NULL
14024 };
14025
14026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14028 if (!SWIG_IsOK(res1)) {
14029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
14030 }
14031 arg1 = reinterpret_cast< wxImage * >(argp1);
14032 ecode2 = SWIG_AsVal_int(obj1, &val2);
14033 if (!SWIG_IsOK(ecode2)) {
14034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
14035 }
14036 arg2 = static_cast< int >(val2);
14037 ecode3 = SWIG_AsVal_int(obj2, &val3);
14038 if (!SWIG_IsOK(ecode3)) {
14039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
14040 }
14041 arg3 = static_cast< int >(val3);
14042 {
14043 PyThreadState* __tstate = wxPyBeginAllowThreads();
14044 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
14045 wxPyEndAllowThreads(__tstate);
14046 if (PyErr_Occurred()) SWIG_fail;
14047 }
14048 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14049 return resultobj;
14050 fail:
14051 return NULL;
14052 }
14053
14054
14055 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14056 PyObject *resultobj = 0;
14057 wxImage *arg1 = (wxImage *) 0 ;
14058 int arg2 ;
14059 SwigValueWrapper<wxImage > result;
14060 void *argp1 = 0 ;
14061 int res1 = 0 ;
14062 int val2 ;
14063 int ecode2 = 0 ;
14064 PyObject * obj0 = 0 ;
14065 PyObject * obj1 = 0 ;
14066 char * kwnames[] = {
14067 (char *) "self",(char *) "radius", NULL
14068 };
14069
14070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
14071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14072 if (!SWIG_IsOK(res1)) {
14073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
14074 }
14075 arg1 = reinterpret_cast< wxImage * >(argp1);
14076 ecode2 = SWIG_AsVal_int(obj1, &val2);
14077 if (!SWIG_IsOK(ecode2)) {
14078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
14079 }
14080 arg2 = static_cast< int >(val2);
14081 {
14082 PyThreadState* __tstate = wxPyBeginAllowThreads();
14083 result = (arg1)->Blur(arg2);
14084 wxPyEndAllowThreads(__tstate);
14085 if (PyErr_Occurred()) SWIG_fail;
14086 }
14087 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14088 return resultobj;
14089 fail:
14090 return NULL;
14091 }
14092
14093
14094 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14095 PyObject *resultobj = 0;
14096 wxImage *arg1 = (wxImage *) 0 ;
14097 int arg2 ;
14098 SwigValueWrapper<wxImage > result;
14099 void *argp1 = 0 ;
14100 int res1 = 0 ;
14101 int val2 ;
14102 int ecode2 = 0 ;
14103 PyObject * obj0 = 0 ;
14104 PyObject * obj1 = 0 ;
14105 char * kwnames[] = {
14106 (char *) "self",(char *) "radius", NULL
14107 };
14108
14109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
14110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14111 if (!SWIG_IsOK(res1)) {
14112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
14113 }
14114 arg1 = reinterpret_cast< wxImage * >(argp1);
14115 ecode2 = SWIG_AsVal_int(obj1, &val2);
14116 if (!SWIG_IsOK(ecode2)) {
14117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
14118 }
14119 arg2 = static_cast< int >(val2);
14120 {
14121 PyThreadState* __tstate = wxPyBeginAllowThreads();
14122 result = (arg1)->BlurHorizontal(arg2);
14123 wxPyEndAllowThreads(__tstate);
14124 if (PyErr_Occurred()) SWIG_fail;
14125 }
14126 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14127 return resultobj;
14128 fail:
14129 return NULL;
14130 }
14131
14132
14133 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14134 PyObject *resultobj = 0;
14135 wxImage *arg1 = (wxImage *) 0 ;
14136 int arg2 ;
14137 SwigValueWrapper<wxImage > result;
14138 void *argp1 = 0 ;
14139 int res1 = 0 ;
14140 int val2 ;
14141 int ecode2 = 0 ;
14142 PyObject * obj0 = 0 ;
14143 PyObject * obj1 = 0 ;
14144 char * kwnames[] = {
14145 (char *) "self",(char *) "radius", NULL
14146 };
14147
14148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
14149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14150 if (!SWIG_IsOK(res1)) {
14151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
14152 }
14153 arg1 = reinterpret_cast< wxImage * >(argp1);
14154 ecode2 = SWIG_AsVal_int(obj1, &val2);
14155 if (!SWIG_IsOK(ecode2)) {
14156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
14157 }
14158 arg2 = static_cast< int >(val2);
14159 {
14160 PyThreadState* __tstate = wxPyBeginAllowThreads();
14161 result = (arg1)->BlurVertical(arg2);
14162 wxPyEndAllowThreads(__tstate);
14163 if (PyErr_Occurred()) SWIG_fail;
14164 }
14165 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14166 return resultobj;
14167 fail:
14168 return NULL;
14169 }
14170
14171
14172 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14173 PyObject *resultobj = 0;
14174 wxImage *arg1 = (wxImage *) 0 ;
14175 int arg2 ;
14176 int arg3 ;
14177 SwigValueWrapper<wxImage > result;
14178 void *argp1 = 0 ;
14179 int res1 = 0 ;
14180 int val2 ;
14181 int ecode2 = 0 ;
14182 int val3 ;
14183 int ecode3 = 0 ;
14184 PyObject * obj0 = 0 ;
14185 PyObject * obj1 = 0 ;
14186 PyObject * obj2 = 0 ;
14187 char * kwnames[] = {
14188 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
14189 };
14190
14191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14193 if (!SWIG_IsOK(res1)) {
14194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
14195 }
14196 arg1 = reinterpret_cast< wxImage * >(argp1);
14197 ecode2 = SWIG_AsVal_int(obj1, &val2);
14198 if (!SWIG_IsOK(ecode2)) {
14199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
14200 }
14201 arg2 = static_cast< int >(val2);
14202 ecode3 = SWIG_AsVal_int(obj2, &val3);
14203 if (!SWIG_IsOK(ecode3)) {
14204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
14205 }
14206 arg3 = static_cast< int >(val3);
14207 {
14208 PyThreadState* __tstate = wxPyBeginAllowThreads();
14209 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
14210 wxPyEndAllowThreads(__tstate);
14211 if (PyErr_Occurred()) SWIG_fail;
14212 }
14213 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14214 return resultobj;
14215 fail:
14216 return NULL;
14217 }
14218
14219
14220 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14221 PyObject *resultobj = 0;
14222 wxImage *arg1 = (wxImage *) 0 ;
14223 int arg2 ;
14224 int arg3 ;
14225 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
14226 wxImage *result = 0 ;
14227 void *argp1 = 0 ;
14228 int res1 = 0 ;
14229 int val2 ;
14230 int ecode2 = 0 ;
14231 int val3 ;
14232 int ecode3 = 0 ;
14233 int val4 ;
14234 int ecode4 = 0 ;
14235 PyObject * obj0 = 0 ;
14236 PyObject * obj1 = 0 ;
14237 PyObject * obj2 = 0 ;
14238 PyObject * obj3 = 0 ;
14239 char * kwnames[] = {
14240 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
14241 };
14242
14243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14245 if (!SWIG_IsOK(res1)) {
14246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
14247 }
14248 arg1 = reinterpret_cast< wxImage * >(argp1);
14249 ecode2 = SWIG_AsVal_int(obj1, &val2);
14250 if (!SWIG_IsOK(ecode2)) {
14251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
14252 }
14253 arg2 = static_cast< int >(val2);
14254 ecode3 = SWIG_AsVal_int(obj2, &val3);
14255 if (!SWIG_IsOK(ecode3)) {
14256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
14257 }
14258 arg3 = static_cast< int >(val3);
14259 if (obj3) {
14260 ecode4 = SWIG_AsVal_int(obj3, &val4);
14261 if (!SWIG_IsOK(ecode4)) {
14262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
14263 }
14264 arg4 = static_cast< int >(val4);
14265 }
14266 {
14267 PyThreadState* __tstate = wxPyBeginAllowThreads();
14268 {
14269 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
14270 result = (wxImage *) &_result_ref;
14271 }
14272 wxPyEndAllowThreads(__tstate);
14273 if (PyErr_Occurred()) SWIG_fail;
14274 }
14275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14276 return resultobj;
14277 fail:
14278 return NULL;
14279 }
14280
14281
14282 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14283 PyObject *resultobj = 0;
14284 wxImage *arg1 = (wxImage *) 0 ;
14285 wxSize *arg2 = 0 ;
14286 wxPoint *arg3 = 0 ;
14287 int arg4 = (int) -1 ;
14288 int arg5 = (int) -1 ;
14289 int arg6 = (int) -1 ;
14290 wxImage *result = 0 ;
14291 void *argp1 = 0 ;
14292 int res1 = 0 ;
14293 wxSize temp2 ;
14294 wxPoint temp3 ;
14295 int val4 ;
14296 int ecode4 = 0 ;
14297 int val5 ;
14298 int ecode5 = 0 ;
14299 int val6 ;
14300 int ecode6 = 0 ;
14301 PyObject * obj0 = 0 ;
14302 PyObject * obj1 = 0 ;
14303 PyObject * obj2 = 0 ;
14304 PyObject * obj3 = 0 ;
14305 PyObject * obj4 = 0 ;
14306 PyObject * obj5 = 0 ;
14307 char * kwnames[] = {
14308 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
14309 };
14310
14311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14313 if (!SWIG_IsOK(res1)) {
14314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
14315 }
14316 arg1 = reinterpret_cast< wxImage * >(argp1);
14317 {
14318 arg2 = &temp2;
14319 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
14320 }
14321 {
14322 arg3 = &temp3;
14323 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14324 }
14325 if (obj3) {
14326 ecode4 = SWIG_AsVal_int(obj3, &val4);
14327 if (!SWIG_IsOK(ecode4)) {
14328 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
14329 }
14330 arg4 = static_cast< int >(val4);
14331 }
14332 if (obj4) {
14333 ecode5 = SWIG_AsVal_int(obj4, &val5);
14334 if (!SWIG_IsOK(ecode5)) {
14335 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
14336 }
14337 arg5 = static_cast< int >(val5);
14338 }
14339 if (obj5) {
14340 ecode6 = SWIG_AsVal_int(obj5, &val6);
14341 if (!SWIG_IsOK(ecode6)) {
14342 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
14343 }
14344 arg6 = static_cast< int >(val6);
14345 }
14346 {
14347 PyThreadState* __tstate = wxPyBeginAllowThreads();
14348 {
14349 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
14350 result = (wxImage *) &_result_ref;
14351 }
14352 wxPyEndAllowThreads(__tstate);
14353 if (PyErr_Occurred()) SWIG_fail;
14354 }
14355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14356 return resultobj;
14357 fail:
14358 return NULL;
14359 }
14360
14361
14362 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14363 PyObject *resultobj = 0;
14364 wxImage *arg1 = (wxImage *) 0 ;
14365 int arg2 ;
14366 int arg3 ;
14367 byte arg4 ;
14368 byte arg5 ;
14369 byte arg6 ;
14370 void *argp1 = 0 ;
14371 int res1 = 0 ;
14372 int val2 ;
14373 int ecode2 = 0 ;
14374 int val3 ;
14375 int ecode3 = 0 ;
14376 unsigned char val4 ;
14377 int ecode4 = 0 ;
14378 unsigned char val5 ;
14379 int ecode5 = 0 ;
14380 unsigned char val6 ;
14381 int ecode6 = 0 ;
14382 PyObject * obj0 = 0 ;
14383 PyObject * obj1 = 0 ;
14384 PyObject * obj2 = 0 ;
14385 PyObject * obj3 = 0 ;
14386 PyObject * obj4 = 0 ;
14387 PyObject * obj5 = 0 ;
14388 char * kwnames[] = {
14389 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
14390 };
14391
14392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14394 if (!SWIG_IsOK(res1)) {
14395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
14396 }
14397 arg1 = reinterpret_cast< wxImage * >(argp1);
14398 ecode2 = SWIG_AsVal_int(obj1, &val2);
14399 if (!SWIG_IsOK(ecode2)) {
14400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
14401 }
14402 arg2 = static_cast< int >(val2);
14403 ecode3 = SWIG_AsVal_int(obj2, &val3);
14404 if (!SWIG_IsOK(ecode3)) {
14405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
14406 }
14407 arg3 = static_cast< int >(val3);
14408 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14409 if (!SWIG_IsOK(ecode4)) {
14410 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
14411 }
14412 arg4 = static_cast< byte >(val4);
14413 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14414 if (!SWIG_IsOK(ecode5)) {
14415 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
14416 }
14417 arg5 = static_cast< byte >(val5);
14418 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
14419 if (!SWIG_IsOK(ecode6)) {
14420 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
14421 }
14422 arg6 = static_cast< byte >(val6);
14423 {
14424 PyThreadState* __tstate = wxPyBeginAllowThreads();
14425 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
14426 wxPyEndAllowThreads(__tstate);
14427 if (PyErr_Occurred()) SWIG_fail;
14428 }
14429 resultobj = SWIG_Py_Void();
14430 return resultobj;
14431 fail:
14432 return NULL;
14433 }
14434
14435
14436 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14437 PyObject *resultobj = 0;
14438 wxImage *arg1 = (wxImage *) 0 ;
14439 wxRect *arg2 = 0 ;
14440 byte arg3 ;
14441 byte arg4 ;
14442 byte arg5 ;
14443 void *argp1 = 0 ;
14444 int res1 = 0 ;
14445 wxRect temp2 ;
14446 unsigned char val3 ;
14447 int ecode3 = 0 ;
14448 unsigned char val4 ;
14449 int ecode4 = 0 ;
14450 unsigned char val5 ;
14451 int ecode5 = 0 ;
14452 PyObject * obj0 = 0 ;
14453 PyObject * obj1 = 0 ;
14454 PyObject * obj2 = 0 ;
14455 PyObject * obj3 = 0 ;
14456 PyObject * obj4 = 0 ;
14457 char * kwnames[] = {
14458 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
14459 };
14460
14461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14463 if (!SWIG_IsOK(res1)) {
14464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
14465 }
14466 arg1 = reinterpret_cast< wxImage * >(argp1);
14467 {
14468 arg2 = &temp2;
14469 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14470 }
14471 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14472 if (!SWIG_IsOK(ecode3)) {
14473 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
14474 }
14475 arg3 = static_cast< byte >(val3);
14476 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14477 if (!SWIG_IsOK(ecode4)) {
14478 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
14479 }
14480 arg4 = static_cast< byte >(val4);
14481 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14482 if (!SWIG_IsOK(ecode5)) {
14483 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
14484 }
14485 arg5 = static_cast< byte >(val5);
14486 {
14487 PyThreadState* __tstate = wxPyBeginAllowThreads();
14488 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14489 wxPyEndAllowThreads(__tstate);
14490 if (PyErr_Occurred()) SWIG_fail;
14491 }
14492 resultobj = SWIG_Py_Void();
14493 return resultobj;
14494 fail:
14495 return NULL;
14496 }
14497
14498
14499 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14500 PyObject *resultobj = 0;
14501 wxImage *arg1 = (wxImage *) 0 ;
14502 int arg2 ;
14503 int arg3 ;
14504 byte result;
14505 void *argp1 = 0 ;
14506 int res1 = 0 ;
14507 int val2 ;
14508 int ecode2 = 0 ;
14509 int val3 ;
14510 int ecode3 = 0 ;
14511 PyObject * obj0 = 0 ;
14512 PyObject * obj1 = 0 ;
14513 PyObject * obj2 = 0 ;
14514 char * kwnames[] = {
14515 (char *) "self",(char *) "x",(char *) "y", NULL
14516 };
14517
14518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14520 if (!SWIG_IsOK(res1)) {
14521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14522 }
14523 arg1 = reinterpret_cast< wxImage * >(argp1);
14524 ecode2 = SWIG_AsVal_int(obj1, &val2);
14525 if (!SWIG_IsOK(ecode2)) {
14526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14527 }
14528 arg2 = static_cast< int >(val2);
14529 ecode3 = SWIG_AsVal_int(obj2, &val3);
14530 if (!SWIG_IsOK(ecode3)) {
14531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14532 }
14533 arg3 = static_cast< int >(val3);
14534 {
14535 PyThreadState* __tstate = wxPyBeginAllowThreads();
14536 result = (byte)(arg1)->GetRed(arg2,arg3);
14537 wxPyEndAllowThreads(__tstate);
14538 if (PyErr_Occurred()) SWIG_fail;
14539 }
14540 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14541 return resultobj;
14542 fail:
14543 return NULL;
14544 }
14545
14546
14547 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14548 PyObject *resultobj = 0;
14549 wxImage *arg1 = (wxImage *) 0 ;
14550 int arg2 ;
14551 int arg3 ;
14552 byte result;
14553 void *argp1 = 0 ;
14554 int res1 = 0 ;
14555 int val2 ;
14556 int ecode2 = 0 ;
14557 int val3 ;
14558 int ecode3 = 0 ;
14559 PyObject * obj0 = 0 ;
14560 PyObject * obj1 = 0 ;
14561 PyObject * obj2 = 0 ;
14562 char * kwnames[] = {
14563 (char *) "self",(char *) "x",(char *) "y", NULL
14564 };
14565
14566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14568 if (!SWIG_IsOK(res1)) {
14569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14570 }
14571 arg1 = reinterpret_cast< wxImage * >(argp1);
14572 ecode2 = SWIG_AsVal_int(obj1, &val2);
14573 if (!SWIG_IsOK(ecode2)) {
14574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14575 }
14576 arg2 = static_cast< int >(val2);
14577 ecode3 = SWIG_AsVal_int(obj2, &val3);
14578 if (!SWIG_IsOK(ecode3)) {
14579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14580 }
14581 arg3 = static_cast< int >(val3);
14582 {
14583 PyThreadState* __tstate = wxPyBeginAllowThreads();
14584 result = (byte)(arg1)->GetGreen(arg2,arg3);
14585 wxPyEndAllowThreads(__tstate);
14586 if (PyErr_Occurred()) SWIG_fail;
14587 }
14588 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14589 return resultobj;
14590 fail:
14591 return NULL;
14592 }
14593
14594
14595 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14596 PyObject *resultobj = 0;
14597 wxImage *arg1 = (wxImage *) 0 ;
14598 int arg2 ;
14599 int arg3 ;
14600 byte result;
14601 void *argp1 = 0 ;
14602 int res1 = 0 ;
14603 int val2 ;
14604 int ecode2 = 0 ;
14605 int val3 ;
14606 int ecode3 = 0 ;
14607 PyObject * obj0 = 0 ;
14608 PyObject * obj1 = 0 ;
14609 PyObject * obj2 = 0 ;
14610 char * kwnames[] = {
14611 (char *) "self",(char *) "x",(char *) "y", NULL
14612 };
14613
14614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14616 if (!SWIG_IsOK(res1)) {
14617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14618 }
14619 arg1 = reinterpret_cast< wxImage * >(argp1);
14620 ecode2 = SWIG_AsVal_int(obj1, &val2);
14621 if (!SWIG_IsOK(ecode2)) {
14622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14623 }
14624 arg2 = static_cast< int >(val2);
14625 ecode3 = SWIG_AsVal_int(obj2, &val3);
14626 if (!SWIG_IsOK(ecode3)) {
14627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14628 }
14629 arg3 = static_cast< int >(val3);
14630 {
14631 PyThreadState* __tstate = wxPyBeginAllowThreads();
14632 result = (byte)(arg1)->GetBlue(arg2,arg3);
14633 wxPyEndAllowThreads(__tstate);
14634 if (PyErr_Occurred()) SWIG_fail;
14635 }
14636 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14637 return resultobj;
14638 fail:
14639 return NULL;
14640 }
14641
14642
14643 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14644 PyObject *resultobj = 0;
14645 wxImage *arg1 = (wxImage *) 0 ;
14646 int arg2 ;
14647 int arg3 ;
14648 byte arg4 ;
14649 void *argp1 = 0 ;
14650 int res1 = 0 ;
14651 int val2 ;
14652 int ecode2 = 0 ;
14653 int val3 ;
14654 int ecode3 = 0 ;
14655 unsigned char val4 ;
14656 int ecode4 = 0 ;
14657 PyObject * obj0 = 0 ;
14658 PyObject * obj1 = 0 ;
14659 PyObject * obj2 = 0 ;
14660 PyObject * obj3 = 0 ;
14661 char * kwnames[] = {
14662 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14663 };
14664
14665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14667 if (!SWIG_IsOK(res1)) {
14668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14669 }
14670 arg1 = reinterpret_cast< wxImage * >(argp1);
14671 ecode2 = SWIG_AsVal_int(obj1, &val2);
14672 if (!SWIG_IsOK(ecode2)) {
14673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14674 }
14675 arg2 = static_cast< int >(val2);
14676 ecode3 = SWIG_AsVal_int(obj2, &val3);
14677 if (!SWIG_IsOK(ecode3)) {
14678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14679 }
14680 arg3 = static_cast< int >(val3);
14681 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14682 if (!SWIG_IsOK(ecode4)) {
14683 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14684 }
14685 arg4 = static_cast< byte >(val4);
14686 {
14687 PyThreadState* __tstate = wxPyBeginAllowThreads();
14688 (arg1)->SetAlpha(arg2,arg3,arg4);
14689 wxPyEndAllowThreads(__tstate);
14690 if (PyErr_Occurred()) SWIG_fail;
14691 }
14692 resultobj = SWIG_Py_Void();
14693 return resultobj;
14694 fail:
14695 return NULL;
14696 }
14697
14698
14699 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14700 PyObject *resultobj = 0;
14701 wxImage *arg1 = (wxImage *) 0 ;
14702 int arg2 ;
14703 int arg3 ;
14704 byte result;
14705 void *argp1 = 0 ;
14706 int res1 = 0 ;
14707 int val2 ;
14708 int ecode2 = 0 ;
14709 int val3 ;
14710 int ecode3 = 0 ;
14711 PyObject * obj0 = 0 ;
14712 PyObject * obj1 = 0 ;
14713 PyObject * obj2 = 0 ;
14714 char * kwnames[] = {
14715 (char *) "self",(char *) "x",(char *) "y", NULL
14716 };
14717
14718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",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_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14722 }
14723 arg1 = reinterpret_cast< wxImage * >(argp1);
14724 ecode2 = SWIG_AsVal_int(obj1, &val2);
14725 if (!SWIG_IsOK(ecode2)) {
14726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14727 }
14728 arg2 = static_cast< int >(val2);
14729 ecode3 = SWIG_AsVal_int(obj2, &val3);
14730 if (!SWIG_IsOK(ecode3)) {
14731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14732 }
14733 arg3 = static_cast< int >(val3);
14734 {
14735 PyThreadState* __tstate = wxPyBeginAllowThreads();
14736 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14737 wxPyEndAllowThreads(__tstate);
14738 if (PyErr_Occurred()) SWIG_fail;
14739 }
14740 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14741 return resultobj;
14742 fail:
14743 return NULL;
14744 }
14745
14746
14747 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14748 PyObject *resultobj = 0;
14749 wxImage *arg1 = (wxImage *) 0 ;
14750 bool result;
14751 void *argp1 = 0 ;
14752 int res1 = 0 ;
14753 PyObject *swig_obj[1] ;
14754
14755 if (!args) SWIG_fail;
14756 swig_obj[0] = args;
14757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14758 if (!SWIG_IsOK(res1)) {
14759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14760 }
14761 arg1 = reinterpret_cast< wxImage * >(argp1);
14762 {
14763 PyThreadState* __tstate = wxPyBeginAllowThreads();
14764 result = (bool)(arg1)->HasAlpha();
14765 wxPyEndAllowThreads(__tstate);
14766 if (PyErr_Occurred()) SWIG_fail;
14767 }
14768 {
14769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14770 }
14771 return resultobj;
14772 fail:
14773 return NULL;
14774 }
14775
14776
14777 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14778 PyObject *resultobj = 0;
14779 wxImage *arg1 = (wxImage *) 0 ;
14780 void *argp1 = 0 ;
14781 int res1 = 0 ;
14782 PyObject *swig_obj[1] ;
14783
14784 if (!args) SWIG_fail;
14785 swig_obj[0] = args;
14786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14787 if (!SWIG_IsOK(res1)) {
14788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14789 }
14790 arg1 = reinterpret_cast< wxImage * >(argp1);
14791 {
14792 PyThreadState* __tstate = wxPyBeginAllowThreads();
14793 (arg1)->InitAlpha();
14794 wxPyEndAllowThreads(__tstate);
14795 if (PyErr_Occurred()) SWIG_fail;
14796 }
14797 resultobj = SWIG_Py_Void();
14798 return resultobj;
14799 fail:
14800 return NULL;
14801 }
14802
14803
14804 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14805 PyObject *resultobj = 0;
14806 wxImage *arg1 = (wxImage *) 0 ;
14807 int arg2 ;
14808 int arg3 ;
14809 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14810 bool result;
14811 void *argp1 = 0 ;
14812 int res1 = 0 ;
14813 int val2 ;
14814 int ecode2 = 0 ;
14815 int val3 ;
14816 int ecode3 = 0 ;
14817 unsigned char val4 ;
14818 int ecode4 = 0 ;
14819 PyObject * obj0 = 0 ;
14820 PyObject * obj1 = 0 ;
14821 PyObject * obj2 = 0 ;
14822 PyObject * obj3 = 0 ;
14823 char * kwnames[] = {
14824 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14825 };
14826
14827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14829 if (!SWIG_IsOK(res1)) {
14830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14831 }
14832 arg1 = reinterpret_cast< wxImage * >(argp1);
14833 ecode2 = SWIG_AsVal_int(obj1, &val2);
14834 if (!SWIG_IsOK(ecode2)) {
14835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14836 }
14837 arg2 = static_cast< int >(val2);
14838 ecode3 = SWIG_AsVal_int(obj2, &val3);
14839 if (!SWIG_IsOK(ecode3)) {
14840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14841 }
14842 arg3 = static_cast< int >(val3);
14843 if (obj3) {
14844 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14845 if (!SWIG_IsOK(ecode4)) {
14846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14847 }
14848 arg4 = static_cast< byte >(val4);
14849 }
14850 {
14851 PyThreadState* __tstate = wxPyBeginAllowThreads();
14852 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14853 wxPyEndAllowThreads(__tstate);
14854 if (PyErr_Occurred()) SWIG_fail;
14855 }
14856 {
14857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14858 }
14859 return resultobj;
14860 fail:
14861 return NULL;
14862 }
14863
14864
14865 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14866 PyObject *resultobj = 0;
14867 wxImage *arg1 = (wxImage *) 0 ;
14868 byte *arg2 = (byte *) 0 ;
14869 byte *arg3 = (byte *) 0 ;
14870 byte *arg4 = (byte *) 0 ;
14871 byte arg5 = (byte) 0 ;
14872 byte arg6 = (byte) 0 ;
14873 byte arg7 = (byte) 0 ;
14874 bool result;
14875 void *argp1 = 0 ;
14876 int res1 = 0 ;
14877 byte temp2 ;
14878 int res2 = SWIG_TMPOBJ ;
14879 byte temp3 ;
14880 int res3 = SWIG_TMPOBJ ;
14881 byte temp4 ;
14882 int res4 = SWIG_TMPOBJ ;
14883 unsigned char val5 ;
14884 int ecode5 = 0 ;
14885 unsigned char val6 ;
14886 int ecode6 = 0 ;
14887 unsigned char val7 ;
14888 int ecode7 = 0 ;
14889 PyObject * obj0 = 0 ;
14890 PyObject * obj1 = 0 ;
14891 PyObject * obj2 = 0 ;
14892 PyObject * obj3 = 0 ;
14893 char * kwnames[] = {
14894 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14895 };
14896
14897 arg2 = &temp2;
14898 arg3 = &temp3;
14899 arg4 = &temp4;
14900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14902 if (!SWIG_IsOK(res1)) {
14903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14904 }
14905 arg1 = reinterpret_cast< wxImage * >(argp1);
14906 if (obj1) {
14907 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14908 if (!SWIG_IsOK(ecode5)) {
14909 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14910 }
14911 arg5 = static_cast< byte >(val5);
14912 }
14913 if (obj2) {
14914 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14915 if (!SWIG_IsOK(ecode6)) {
14916 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14917 }
14918 arg6 = static_cast< byte >(val6);
14919 }
14920 if (obj3) {
14921 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14922 if (!SWIG_IsOK(ecode7)) {
14923 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14924 }
14925 arg7 = static_cast< byte >(val7);
14926 }
14927 {
14928 PyThreadState* __tstate = wxPyBeginAllowThreads();
14929 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14930 wxPyEndAllowThreads(__tstate);
14931 if (PyErr_Occurred()) SWIG_fail;
14932 }
14933 {
14934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14935 }
14936 if (SWIG_IsTmpObj(res2)) {
14937 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14938 } else {
14939 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14940 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14941 }
14942 if (SWIG_IsTmpObj(res3)) {
14943 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14944 } else {
14945 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14946 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14947 }
14948 if (SWIG_IsTmpObj(res4)) {
14949 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14950 } else {
14951 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14952 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14953 }
14954 return resultobj;
14955 fail:
14956 return NULL;
14957 }
14958
14959
14960 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14961 PyObject *resultobj = 0;
14962 wxImage *arg1 = (wxImage *) 0 ;
14963 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14964 bool result;
14965 void *argp1 = 0 ;
14966 int res1 = 0 ;
14967 unsigned char val2 ;
14968 int ecode2 = 0 ;
14969 PyObject * obj0 = 0 ;
14970 PyObject * obj1 = 0 ;
14971 char * kwnames[] = {
14972 (char *) "self",(char *) "threshold", NULL
14973 };
14974
14975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14977 if (!SWIG_IsOK(res1)) {
14978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14979 }
14980 arg1 = reinterpret_cast< wxImage * >(argp1);
14981 if (obj1) {
14982 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14983 if (!SWIG_IsOK(ecode2)) {
14984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14985 }
14986 arg2 = static_cast< byte >(val2);
14987 }
14988 {
14989 PyThreadState* __tstate = wxPyBeginAllowThreads();
14990 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
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_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15004 PyObject *resultobj = 0;
15005 wxImage *arg1 = (wxImage *) 0 ;
15006 byte arg2 ;
15007 byte arg3 ;
15008 byte arg4 ;
15009 bool result;
15010 void *argp1 = 0 ;
15011 int res1 = 0 ;
15012 unsigned char val2 ;
15013 int ecode2 = 0 ;
15014 unsigned char val3 ;
15015 int ecode3 = 0 ;
15016 unsigned char val4 ;
15017 int ecode4 = 0 ;
15018 PyObject * obj0 = 0 ;
15019 PyObject * obj1 = 0 ;
15020 PyObject * obj2 = 0 ;
15021 PyObject * obj3 = 0 ;
15022 char * kwnames[] = {
15023 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15024 };
15025
15026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15028 if (!SWIG_IsOK(res1)) {
15029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
15030 }
15031 arg1 = reinterpret_cast< wxImage * >(argp1);
15032 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15033 if (!SWIG_IsOK(ecode2)) {
15034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
15035 }
15036 arg2 = static_cast< byte >(val2);
15037 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15038 if (!SWIG_IsOK(ecode3)) {
15039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
15040 }
15041 arg3 = static_cast< byte >(val3);
15042 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15043 if (!SWIG_IsOK(ecode4)) {
15044 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
15045 }
15046 arg4 = static_cast< byte >(val4);
15047 {
15048 PyThreadState* __tstate = wxPyBeginAllowThreads();
15049 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
15050 wxPyEndAllowThreads(__tstate);
15051 if (PyErr_Occurred()) SWIG_fail;
15052 }
15053 {
15054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15055 }
15056 return resultobj;
15057 fail:
15058 return NULL;
15059 }
15060
15061
15062 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15063 PyObject *resultobj = 0;
15064 wxImage *arg1 = (wxImage *) 0 ;
15065 wxImage *arg2 = 0 ;
15066 byte arg3 ;
15067 byte arg4 ;
15068 byte arg5 ;
15069 bool result;
15070 void *argp1 = 0 ;
15071 int res1 = 0 ;
15072 void *argp2 = 0 ;
15073 int res2 = 0 ;
15074 unsigned char val3 ;
15075 int ecode3 = 0 ;
15076 unsigned char val4 ;
15077 int ecode4 = 0 ;
15078 unsigned char val5 ;
15079 int ecode5 = 0 ;
15080 PyObject * obj0 = 0 ;
15081 PyObject * obj1 = 0 ;
15082 PyObject * obj2 = 0 ;
15083 PyObject * obj3 = 0 ;
15084 PyObject * obj4 = 0 ;
15085 char * kwnames[] = {
15086 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
15087 };
15088
15089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15091 if (!SWIG_IsOK(res1)) {
15092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
15093 }
15094 arg1 = reinterpret_cast< wxImage * >(argp1);
15095 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15096 if (!SWIG_IsOK(res2)) {
15097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15098 }
15099 if (!argp2) {
15100 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15101 }
15102 arg2 = reinterpret_cast< wxImage * >(argp2);
15103 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15104 if (!SWIG_IsOK(ecode3)) {
15105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
15106 }
15107 arg3 = static_cast< byte >(val3);
15108 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15109 if (!SWIG_IsOK(ecode4)) {
15110 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
15111 }
15112 arg4 = static_cast< byte >(val4);
15113 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15114 if (!SWIG_IsOK(ecode5)) {
15115 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
15116 }
15117 arg5 = static_cast< byte >(val5);
15118 {
15119 PyThreadState* __tstate = wxPyBeginAllowThreads();
15120 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
15121 wxPyEndAllowThreads(__tstate);
15122 if (PyErr_Occurred()) SWIG_fail;
15123 }
15124 {
15125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15126 }
15127 return resultobj;
15128 fail:
15129 return NULL;
15130 }
15131
15132
15133 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15134 PyObject *resultobj = 0;
15135 wxString *arg1 = 0 ;
15136 bool result;
15137 bool temp1 = false ;
15138 PyObject * obj0 = 0 ;
15139 char * kwnames[] = {
15140 (char *) "filename", NULL
15141 };
15142
15143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
15144 {
15145 arg1 = wxString_in_helper(obj0);
15146 if (arg1 == NULL) SWIG_fail;
15147 temp1 = true;
15148 }
15149 {
15150 PyThreadState* __tstate = wxPyBeginAllowThreads();
15151 result = (bool)wxImage::CanRead((wxString const &)*arg1);
15152 wxPyEndAllowThreads(__tstate);
15153 if (PyErr_Occurred()) SWIG_fail;
15154 }
15155 {
15156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15157 }
15158 {
15159 if (temp1)
15160 delete arg1;
15161 }
15162 return resultobj;
15163 fail:
15164 {
15165 if (temp1)
15166 delete arg1;
15167 }
15168 return NULL;
15169 }
15170
15171
15172 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15173 PyObject *resultobj = 0;
15174 wxString *arg1 = 0 ;
15175 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15176 int result;
15177 bool temp1 = false ;
15178 long val2 ;
15179 int ecode2 = 0 ;
15180 PyObject * obj0 = 0 ;
15181 PyObject * obj1 = 0 ;
15182 char * kwnames[] = {
15183 (char *) "filename",(char *) "type", NULL
15184 };
15185
15186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
15187 {
15188 arg1 = wxString_in_helper(obj0);
15189 if (arg1 == NULL) SWIG_fail;
15190 temp1 = true;
15191 }
15192 if (obj1) {
15193 ecode2 = SWIG_AsVal_long(obj1, &val2);
15194 if (!SWIG_IsOK(ecode2)) {
15195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
15196 }
15197 arg2 = static_cast< long >(val2);
15198 }
15199 {
15200 PyThreadState* __tstate = wxPyBeginAllowThreads();
15201 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
15202 wxPyEndAllowThreads(__tstate);
15203 if (PyErr_Occurred()) SWIG_fail;
15204 }
15205 resultobj = SWIG_From_int(static_cast< int >(result));
15206 {
15207 if (temp1)
15208 delete arg1;
15209 }
15210 return resultobj;
15211 fail:
15212 {
15213 if (temp1)
15214 delete arg1;
15215 }
15216 return NULL;
15217 }
15218
15219
15220 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15221 PyObject *resultobj = 0;
15222 wxImage *arg1 = (wxImage *) 0 ;
15223 wxString *arg2 = 0 ;
15224 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15225 int arg4 = (int) -1 ;
15226 bool result;
15227 void *argp1 = 0 ;
15228 int res1 = 0 ;
15229 bool temp2 = false ;
15230 long val3 ;
15231 int ecode3 = 0 ;
15232 int val4 ;
15233 int ecode4 = 0 ;
15234 PyObject * obj0 = 0 ;
15235 PyObject * obj1 = 0 ;
15236 PyObject * obj2 = 0 ;
15237 PyObject * obj3 = 0 ;
15238 char * kwnames[] = {
15239 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
15240 };
15241
15242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15244 if (!SWIG_IsOK(res1)) {
15245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
15246 }
15247 arg1 = reinterpret_cast< wxImage * >(argp1);
15248 {
15249 arg2 = wxString_in_helper(obj1);
15250 if (arg2 == NULL) SWIG_fail;
15251 temp2 = true;
15252 }
15253 if (obj2) {
15254 ecode3 = SWIG_AsVal_long(obj2, &val3);
15255 if (!SWIG_IsOK(ecode3)) {
15256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
15257 }
15258 arg3 = static_cast< long >(val3);
15259 }
15260 if (obj3) {
15261 ecode4 = SWIG_AsVal_int(obj3, &val4);
15262 if (!SWIG_IsOK(ecode4)) {
15263 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
15264 }
15265 arg4 = static_cast< int >(val4);
15266 }
15267 {
15268 PyThreadState* __tstate = wxPyBeginAllowThreads();
15269 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
15270 wxPyEndAllowThreads(__tstate);
15271 if (PyErr_Occurred()) SWIG_fail;
15272 }
15273 {
15274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15275 }
15276 {
15277 if (temp2)
15278 delete arg2;
15279 }
15280 return resultobj;
15281 fail:
15282 {
15283 if (temp2)
15284 delete arg2;
15285 }
15286 return NULL;
15287 }
15288
15289
15290 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15291 PyObject *resultobj = 0;
15292 wxImage *arg1 = (wxImage *) 0 ;
15293 wxString *arg2 = 0 ;
15294 wxString *arg3 = 0 ;
15295 int arg4 = (int) -1 ;
15296 bool result;
15297 void *argp1 = 0 ;
15298 int res1 = 0 ;
15299 bool temp2 = false ;
15300 bool temp3 = false ;
15301 int val4 ;
15302 int ecode4 = 0 ;
15303 PyObject * obj0 = 0 ;
15304 PyObject * obj1 = 0 ;
15305 PyObject * obj2 = 0 ;
15306 PyObject * obj3 = 0 ;
15307 char * kwnames[] = {
15308 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
15309 };
15310
15311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15313 if (!SWIG_IsOK(res1)) {
15314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15315 }
15316 arg1 = reinterpret_cast< wxImage * >(argp1);
15317 {
15318 arg2 = wxString_in_helper(obj1);
15319 if (arg2 == NULL) SWIG_fail;
15320 temp2 = true;
15321 }
15322 {
15323 arg3 = wxString_in_helper(obj2);
15324 if (arg3 == NULL) SWIG_fail;
15325 temp3 = true;
15326 }
15327 if (obj3) {
15328 ecode4 = SWIG_AsVal_int(obj3, &val4);
15329 if (!SWIG_IsOK(ecode4)) {
15330 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
15331 }
15332 arg4 = static_cast< int >(val4);
15333 }
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15337 wxPyEndAllowThreads(__tstate);
15338 if (PyErr_Occurred()) SWIG_fail;
15339 }
15340 {
15341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15342 }
15343 {
15344 if (temp2)
15345 delete arg2;
15346 }
15347 {
15348 if (temp3)
15349 delete arg3;
15350 }
15351 return resultobj;
15352 fail:
15353 {
15354 if (temp2)
15355 delete arg2;
15356 }
15357 {
15358 if (temp3)
15359 delete arg3;
15360 }
15361 return NULL;
15362 }
15363
15364
15365 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15366 PyObject *resultobj = 0;
15367 wxImage *arg1 = (wxImage *) 0 ;
15368 wxString *arg2 = 0 ;
15369 int arg3 ;
15370 bool result;
15371 void *argp1 = 0 ;
15372 int res1 = 0 ;
15373 bool temp2 = false ;
15374 int val3 ;
15375 int ecode3 = 0 ;
15376 PyObject * obj0 = 0 ;
15377 PyObject * obj1 = 0 ;
15378 PyObject * obj2 = 0 ;
15379 char * kwnames[] = {
15380 (char *) "self",(char *) "name",(char *) "type", NULL
15381 };
15382
15383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15385 if (!SWIG_IsOK(res1)) {
15386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
15387 }
15388 arg1 = reinterpret_cast< wxImage * >(argp1);
15389 {
15390 arg2 = wxString_in_helper(obj1);
15391 if (arg2 == NULL) SWIG_fail;
15392 temp2 = true;
15393 }
15394 ecode3 = SWIG_AsVal_int(obj2, &val3);
15395 if (!SWIG_IsOK(ecode3)) {
15396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
15397 }
15398 arg3 = static_cast< int >(val3);
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
15402 wxPyEndAllowThreads(__tstate);
15403 if (PyErr_Occurred()) SWIG_fail;
15404 }
15405 {
15406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15407 }
15408 {
15409 if (temp2)
15410 delete arg2;
15411 }
15412 return resultobj;
15413 fail:
15414 {
15415 if (temp2)
15416 delete arg2;
15417 }
15418 return NULL;
15419 }
15420
15421
15422 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15423 PyObject *resultobj = 0;
15424 wxImage *arg1 = (wxImage *) 0 ;
15425 wxString *arg2 = 0 ;
15426 wxString *arg3 = 0 ;
15427 bool result;
15428 void *argp1 = 0 ;
15429 int res1 = 0 ;
15430 bool temp2 = false ;
15431 bool temp3 = false ;
15432 PyObject * obj0 = 0 ;
15433 PyObject * obj1 = 0 ;
15434 PyObject * obj2 = 0 ;
15435 char * kwnames[] = {
15436 (char *) "self",(char *) "name",(char *) "mimetype", NULL
15437 };
15438
15439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15441 if (!SWIG_IsOK(res1)) {
15442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15443 }
15444 arg1 = reinterpret_cast< wxImage * >(argp1);
15445 {
15446 arg2 = wxString_in_helper(obj1);
15447 if (arg2 == NULL) SWIG_fail;
15448 temp2 = true;
15449 }
15450 {
15451 arg3 = wxString_in_helper(obj2);
15452 if (arg3 == NULL) SWIG_fail;
15453 temp3 = true;
15454 }
15455 {
15456 PyThreadState* __tstate = wxPyBeginAllowThreads();
15457 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
15458 wxPyEndAllowThreads(__tstate);
15459 if (PyErr_Occurred()) SWIG_fail;
15460 }
15461 {
15462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15463 }
15464 {
15465 if (temp2)
15466 delete arg2;
15467 }
15468 {
15469 if (temp3)
15470 delete arg3;
15471 }
15472 return resultobj;
15473 fail:
15474 {
15475 if (temp2)
15476 delete arg2;
15477 }
15478 {
15479 if (temp3)
15480 delete arg3;
15481 }
15482 return NULL;
15483 }
15484
15485
15486 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj = 0;
15488 wxInputStream *arg1 = 0 ;
15489 bool result;
15490 wxPyInputStream *temp1 ;
15491 bool created1 ;
15492 PyObject * obj0 = 0 ;
15493 char * kwnames[] = {
15494 (char *) "stream", NULL
15495 };
15496
15497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15498 {
15499 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15500 arg1 = temp1->m_wxis;
15501 created1 = false;
15502 } else {
15503 PyErr_Clear(); // clear the failure of the wxPyConvert above
15504 arg1 = wxPyCBInputStream_create(obj0, false);
15505 if (arg1 == NULL) {
15506 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15507 SWIG_fail;
15508 }
15509 created1 = true;
15510 }
15511 }
15512 {
15513 PyThreadState* __tstate = wxPyBeginAllowThreads();
15514 result = (bool)wxImage::CanRead(*arg1);
15515 wxPyEndAllowThreads(__tstate);
15516 if (PyErr_Occurred()) SWIG_fail;
15517 }
15518 {
15519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15520 }
15521 {
15522 if (created1) delete arg1;
15523 }
15524 return resultobj;
15525 fail:
15526 {
15527 if (created1) delete arg1;
15528 }
15529 return NULL;
15530 }
15531
15532
15533 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15534 PyObject *resultobj = 0;
15535 wxImage *arg1 = (wxImage *) 0 ;
15536 wxInputStream *arg2 = 0 ;
15537 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15538 int arg4 = (int) -1 ;
15539 bool result;
15540 void *argp1 = 0 ;
15541 int res1 = 0 ;
15542 wxPyInputStream *temp2 ;
15543 bool created2 ;
15544 long val3 ;
15545 int ecode3 = 0 ;
15546 int val4 ;
15547 int ecode4 = 0 ;
15548 PyObject * obj0 = 0 ;
15549 PyObject * obj1 = 0 ;
15550 PyObject * obj2 = 0 ;
15551 PyObject * obj3 = 0 ;
15552 char * kwnames[] = {
15553 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15554 };
15555
15556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15558 if (!SWIG_IsOK(res1)) {
15559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15560 }
15561 arg1 = reinterpret_cast< wxImage * >(argp1);
15562 {
15563 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15564 arg2 = temp2->m_wxis;
15565 created2 = false;
15566 } else {
15567 PyErr_Clear(); // clear the failure of the wxPyConvert above
15568 arg2 = wxPyCBInputStream_create(obj1, false);
15569 if (arg2 == NULL) {
15570 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15571 SWIG_fail;
15572 }
15573 created2 = true;
15574 }
15575 }
15576 if (obj2) {
15577 ecode3 = SWIG_AsVal_long(obj2, &val3);
15578 if (!SWIG_IsOK(ecode3)) {
15579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15580 }
15581 arg3 = static_cast< long >(val3);
15582 }
15583 if (obj3) {
15584 ecode4 = SWIG_AsVal_int(obj3, &val4);
15585 if (!SWIG_IsOK(ecode4)) {
15586 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15587 }
15588 arg4 = static_cast< int >(val4);
15589 }
15590 {
15591 PyThreadState* __tstate = wxPyBeginAllowThreads();
15592 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15593 wxPyEndAllowThreads(__tstate);
15594 if (PyErr_Occurred()) SWIG_fail;
15595 }
15596 {
15597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15598 }
15599 {
15600 if (created2) delete arg2;
15601 }
15602 return resultobj;
15603 fail:
15604 {
15605 if (created2) delete arg2;
15606 }
15607 return NULL;
15608 }
15609
15610
15611 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15612 PyObject *resultobj = 0;
15613 wxImage *arg1 = (wxImage *) 0 ;
15614 wxInputStream *arg2 = 0 ;
15615 wxString *arg3 = 0 ;
15616 int arg4 = (int) -1 ;
15617 bool result;
15618 void *argp1 = 0 ;
15619 int res1 = 0 ;
15620 wxPyInputStream *temp2 ;
15621 bool created2 ;
15622 bool temp3 = false ;
15623 int val4 ;
15624 int ecode4 = 0 ;
15625 PyObject * obj0 = 0 ;
15626 PyObject * obj1 = 0 ;
15627 PyObject * obj2 = 0 ;
15628 PyObject * obj3 = 0 ;
15629 char * kwnames[] = {
15630 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15631 };
15632
15633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15635 if (!SWIG_IsOK(res1)) {
15636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15637 }
15638 arg1 = reinterpret_cast< wxImage * >(argp1);
15639 {
15640 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15641 arg2 = temp2->m_wxis;
15642 created2 = false;
15643 } else {
15644 PyErr_Clear(); // clear the failure of the wxPyConvert above
15645 arg2 = wxPyCBInputStream_create(obj1, false);
15646 if (arg2 == NULL) {
15647 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15648 SWIG_fail;
15649 }
15650 created2 = true;
15651 }
15652 }
15653 {
15654 arg3 = wxString_in_helper(obj2);
15655 if (arg3 == NULL) SWIG_fail;
15656 temp3 = true;
15657 }
15658 if (obj3) {
15659 ecode4 = SWIG_AsVal_int(obj3, &val4);
15660 if (!SWIG_IsOK(ecode4)) {
15661 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15662 }
15663 arg4 = static_cast< int >(val4);
15664 }
15665 {
15666 PyThreadState* __tstate = wxPyBeginAllowThreads();
15667 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15668 wxPyEndAllowThreads(__tstate);
15669 if (PyErr_Occurred()) SWIG_fail;
15670 }
15671 {
15672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15673 }
15674 {
15675 if (created2) delete arg2;
15676 }
15677 {
15678 if (temp3)
15679 delete arg3;
15680 }
15681 return resultobj;
15682 fail:
15683 {
15684 if (created2) delete arg2;
15685 }
15686 {
15687 if (temp3)
15688 delete arg3;
15689 }
15690 return NULL;
15691 }
15692
15693
15694 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15695 PyObject *resultobj = 0;
15696 wxImage *arg1 = (wxImage *) 0 ;
15697 bool result;
15698 void *argp1 = 0 ;
15699 int res1 = 0 ;
15700 PyObject *swig_obj[1] ;
15701
15702 if (!args) SWIG_fail;
15703 swig_obj[0] = args;
15704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15705 if (!SWIG_IsOK(res1)) {
15706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
15707 }
15708 arg1 = reinterpret_cast< wxImage * >(argp1);
15709 {
15710 PyThreadState* __tstate = wxPyBeginAllowThreads();
15711 result = (bool)(arg1)->IsOk();
15712 wxPyEndAllowThreads(__tstate);
15713 if (PyErr_Occurred()) SWIG_fail;
15714 }
15715 {
15716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15717 }
15718 return resultobj;
15719 fail:
15720 return NULL;
15721 }
15722
15723
15724 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15725 PyObject *resultobj = 0;
15726 wxImage *arg1 = (wxImage *) 0 ;
15727 int result;
15728 void *argp1 = 0 ;
15729 int res1 = 0 ;
15730 PyObject *swig_obj[1] ;
15731
15732 if (!args) SWIG_fail;
15733 swig_obj[0] = args;
15734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15735 if (!SWIG_IsOK(res1)) {
15736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15737 }
15738 arg1 = reinterpret_cast< wxImage * >(argp1);
15739 {
15740 PyThreadState* __tstate = wxPyBeginAllowThreads();
15741 result = (int)(arg1)->GetWidth();
15742 wxPyEndAllowThreads(__tstate);
15743 if (PyErr_Occurred()) SWIG_fail;
15744 }
15745 resultobj = SWIG_From_int(static_cast< int >(result));
15746 return resultobj;
15747 fail:
15748 return NULL;
15749 }
15750
15751
15752 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15753 PyObject *resultobj = 0;
15754 wxImage *arg1 = (wxImage *) 0 ;
15755 int result;
15756 void *argp1 = 0 ;
15757 int res1 = 0 ;
15758 PyObject *swig_obj[1] ;
15759
15760 if (!args) SWIG_fail;
15761 swig_obj[0] = args;
15762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15763 if (!SWIG_IsOK(res1)) {
15764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15765 }
15766 arg1 = reinterpret_cast< wxImage * >(argp1);
15767 {
15768 PyThreadState* __tstate = wxPyBeginAllowThreads();
15769 result = (int)(arg1)->GetHeight();
15770 wxPyEndAllowThreads(__tstate);
15771 if (PyErr_Occurred()) SWIG_fail;
15772 }
15773 resultobj = SWIG_From_int(static_cast< int >(result));
15774 return resultobj;
15775 fail:
15776 return NULL;
15777 }
15778
15779
15780 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15781 PyObject *resultobj = 0;
15782 wxImage *arg1 = (wxImage *) 0 ;
15783 wxSize result;
15784 void *argp1 = 0 ;
15785 int res1 = 0 ;
15786 PyObject *swig_obj[1] ;
15787
15788 if (!args) SWIG_fail;
15789 swig_obj[0] = args;
15790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15791 if (!SWIG_IsOK(res1)) {
15792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15793 }
15794 arg1 = reinterpret_cast< wxImage * >(argp1);
15795 {
15796 PyThreadState* __tstate = wxPyBeginAllowThreads();
15797 result = wxImage_GetSize(arg1);
15798 wxPyEndAllowThreads(__tstate);
15799 if (PyErr_Occurred()) SWIG_fail;
15800 }
15801 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15802 return resultobj;
15803 fail:
15804 return NULL;
15805 }
15806
15807
15808 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15809 PyObject *resultobj = 0;
15810 wxImage *arg1 = (wxImage *) 0 ;
15811 wxRect *arg2 = 0 ;
15812 SwigValueWrapper<wxImage > result;
15813 void *argp1 = 0 ;
15814 int res1 = 0 ;
15815 wxRect temp2 ;
15816 PyObject * obj0 = 0 ;
15817 PyObject * obj1 = 0 ;
15818 char * kwnames[] = {
15819 (char *) "self",(char *) "rect", NULL
15820 };
15821
15822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15824 if (!SWIG_IsOK(res1)) {
15825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15826 }
15827 arg1 = reinterpret_cast< wxImage * >(argp1);
15828 {
15829 arg2 = &temp2;
15830 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15831 }
15832 {
15833 PyThreadState* __tstate = wxPyBeginAllowThreads();
15834 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15835 wxPyEndAllowThreads(__tstate);
15836 if (PyErr_Occurred()) SWIG_fail;
15837 }
15838 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15839 return resultobj;
15840 fail:
15841 return NULL;
15842 }
15843
15844
15845 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15846 PyObject *resultobj = 0;
15847 wxImage *arg1 = (wxImage *) 0 ;
15848 wxSize *arg2 = 0 ;
15849 wxPoint *arg3 = 0 ;
15850 int arg4 = (int) -1 ;
15851 int arg5 = (int) -1 ;
15852 int arg6 = (int) -1 ;
15853 SwigValueWrapper<wxImage > result;
15854 void *argp1 = 0 ;
15855 int res1 = 0 ;
15856 wxSize temp2 ;
15857 wxPoint temp3 ;
15858 int val4 ;
15859 int ecode4 = 0 ;
15860 int val5 ;
15861 int ecode5 = 0 ;
15862 int val6 ;
15863 int ecode6 = 0 ;
15864 PyObject * obj0 = 0 ;
15865 PyObject * obj1 = 0 ;
15866 PyObject * obj2 = 0 ;
15867 PyObject * obj3 = 0 ;
15868 PyObject * obj4 = 0 ;
15869 PyObject * obj5 = 0 ;
15870 char * kwnames[] = {
15871 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15872 };
15873
15874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15876 if (!SWIG_IsOK(res1)) {
15877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15878 }
15879 arg1 = reinterpret_cast< wxImage * >(argp1);
15880 {
15881 arg2 = &temp2;
15882 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15883 }
15884 {
15885 arg3 = &temp3;
15886 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15887 }
15888 if (obj3) {
15889 ecode4 = SWIG_AsVal_int(obj3, &val4);
15890 if (!SWIG_IsOK(ecode4)) {
15891 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15892 }
15893 arg4 = static_cast< int >(val4);
15894 }
15895 if (obj4) {
15896 ecode5 = SWIG_AsVal_int(obj4, &val5);
15897 if (!SWIG_IsOK(ecode5)) {
15898 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15899 }
15900 arg5 = static_cast< int >(val5);
15901 }
15902 if (obj5) {
15903 ecode6 = SWIG_AsVal_int(obj5, &val6);
15904 if (!SWIG_IsOK(ecode6)) {
15905 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15906 }
15907 arg6 = static_cast< int >(val6);
15908 }
15909 {
15910 PyThreadState* __tstate = wxPyBeginAllowThreads();
15911 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15912 wxPyEndAllowThreads(__tstate);
15913 if (PyErr_Occurred()) SWIG_fail;
15914 }
15915 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15916 return resultobj;
15917 fail:
15918 return NULL;
15919 }
15920
15921
15922 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15923 PyObject *resultobj = 0;
15924 wxImage *arg1 = (wxImage *) 0 ;
15925 SwigValueWrapper<wxImage > result;
15926 void *argp1 = 0 ;
15927 int res1 = 0 ;
15928 PyObject *swig_obj[1] ;
15929
15930 if (!args) SWIG_fail;
15931 swig_obj[0] = args;
15932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15933 if (!SWIG_IsOK(res1)) {
15934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15935 }
15936 arg1 = reinterpret_cast< wxImage * >(argp1);
15937 {
15938 PyThreadState* __tstate = wxPyBeginAllowThreads();
15939 result = (arg1)->Copy();
15940 wxPyEndAllowThreads(__tstate);
15941 if (PyErr_Occurred()) SWIG_fail;
15942 }
15943 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15944 return resultobj;
15945 fail:
15946 return NULL;
15947 }
15948
15949
15950 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15951 PyObject *resultobj = 0;
15952 wxImage *arg1 = (wxImage *) 0 ;
15953 wxImage *arg2 = 0 ;
15954 int arg3 ;
15955 int arg4 ;
15956 void *argp1 = 0 ;
15957 int res1 = 0 ;
15958 void *argp2 = 0 ;
15959 int res2 = 0 ;
15960 int val3 ;
15961 int ecode3 = 0 ;
15962 int val4 ;
15963 int ecode4 = 0 ;
15964 PyObject * obj0 = 0 ;
15965 PyObject * obj1 = 0 ;
15966 PyObject * obj2 = 0 ;
15967 PyObject * obj3 = 0 ;
15968 char * kwnames[] = {
15969 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15970 };
15971
15972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15974 if (!SWIG_IsOK(res1)) {
15975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15976 }
15977 arg1 = reinterpret_cast< wxImage * >(argp1);
15978 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15979 if (!SWIG_IsOK(res2)) {
15980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15981 }
15982 if (!argp2) {
15983 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15984 }
15985 arg2 = reinterpret_cast< wxImage * >(argp2);
15986 ecode3 = SWIG_AsVal_int(obj2, &val3);
15987 if (!SWIG_IsOK(ecode3)) {
15988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15989 }
15990 arg3 = static_cast< int >(val3);
15991 ecode4 = SWIG_AsVal_int(obj3, &val4);
15992 if (!SWIG_IsOK(ecode4)) {
15993 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15994 }
15995 arg4 = static_cast< int >(val4);
15996 {
15997 PyThreadState* __tstate = wxPyBeginAllowThreads();
15998 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15999 wxPyEndAllowThreads(__tstate);
16000 if (PyErr_Occurred()) SWIG_fail;
16001 }
16002 resultobj = SWIG_Py_Void();
16003 return resultobj;
16004 fail:
16005 return NULL;
16006 }
16007
16008
16009 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16010 PyObject *resultobj = 0;
16011 wxImage *arg1 = (wxImage *) 0 ;
16012 PyObject *result = 0 ;
16013 void *argp1 = 0 ;
16014 int res1 = 0 ;
16015 PyObject *swig_obj[1] ;
16016
16017 if (!args) SWIG_fail;
16018 swig_obj[0] = args;
16019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16020 if (!SWIG_IsOK(res1)) {
16021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
16022 }
16023 arg1 = reinterpret_cast< wxImage * >(argp1);
16024 {
16025 PyThreadState* __tstate = wxPyBeginAllowThreads();
16026 result = (PyObject *)wxImage_GetData(arg1);
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 resultobj = result;
16031 return resultobj;
16032 fail:
16033 return NULL;
16034 }
16035
16036
16037 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16038 PyObject *resultobj = 0;
16039 wxImage *arg1 = (wxImage *) 0 ;
16040 buffer arg2 ;
16041 int arg3 ;
16042 void *argp1 = 0 ;
16043 int res1 = 0 ;
16044 Py_ssize_t temp2 ;
16045 PyObject * obj0 = 0 ;
16046 PyObject * obj1 = 0 ;
16047 char * kwnames[] = {
16048 (char *) "self",(char *) "data", NULL
16049 };
16050
16051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
16052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16053 if (!SWIG_IsOK(res1)) {
16054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
16055 }
16056 arg1 = reinterpret_cast< wxImage * >(argp1);
16057 {
16058 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16059 arg3 = (int)temp2;
16060 }
16061 {
16062 PyThreadState* __tstate = wxPyBeginAllowThreads();
16063 wxImage_SetData(arg1,arg2,arg3);
16064 wxPyEndAllowThreads(__tstate);
16065 if (PyErr_Occurred()) SWIG_fail;
16066 }
16067 resultobj = SWIG_Py_Void();
16068 return resultobj;
16069 fail:
16070 return NULL;
16071 }
16072
16073
16074 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16075 PyObject *resultobj = 0;
16076 wxImage *arg1 = (wxImage *) 0 ;
16077 PyObject *result = 0 ;
16078 void *argp1 = 0 ;
16079 int res1 = 0 ;
16080 PyObject *swig_obj[1] ;
16081
16082 if (!args) SWIG_fail;
16083 swig_obj[0] = args;
16084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16085 if (!SWIG_IsOK(res1)) {
16086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16087 }
16088 arg1 = reinterpret_cast< wxImage * >(argp1);
16089 {
16090 PyThreadState* __tstate = wxPyBeginAllowThreads();
16091 result = (PyObject *)wxImage_GetDataBuffer(arg1);
16092 wxPyEndAllowThreads(__tstate);
16093 if (PyErr_Occurred()) SWIG_fail;
16094 }
16095 resultobj = result;
16096 return resultobj;
16097 fail:
16098 return NULL;
16099 }
16100
16101
16102 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16103 PyObject *resultobj = 0;
16104 wxImage *arg1 = (wxImage *) 0 ;
16105 buffer arg2 ;
16106 int arg3 ;
16107 void *argp1 = 0 ;
16108 int res1 = 0 ;
16109 Py_ssize_t temp2 ;
16110 PyObject * obj0 = 0 ;
16111 PyObject * obj1 = 0 ;
16112 char * kwnames[] = {
16113 (char *) "self",(char *) "data", NULL
16114 };
16115
16116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16118 if (!SWIG_IsOK(res1)) {
16119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16120 }
16121 arg1 = reinterpret_cast< wxImage * >(argp1);
16122 {
16123 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16124 arg3 = (int)temp2;
16125 }
16126 {
16127 PyThreadState* __tstate = wxPyBeginAllowThreads();
16128 wxImage_SetDataBuffer(arg1,arg2,arg3);
16129 wxPyEndAllowThreads(__tstate);
16130 if (PyErr_Occurred()) SWIG_fail;
16131 }
16132 resultobj = SWIG_Py_Void();
16133 return resultobj;
16134 fail:
16135 return NULL;
16136 }
16137
16138
16139 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16140 PyObject *resultobj = 0;
16141 wxImage *arg1 = (wxImage *) 0 ;
16142 PyObject *result = 0 ;
16143 void *argp1 = 0 ;
16144 int res1 = 0 ;
16145 PyObject *swig_obj[1] ;
16146
16147 if (!args) SWIG_fail;
16148 swig_obj[0] = args;
16149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16150 if (!SWIG_IsOK(res1)) {
16151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16152 }
16153 arg1 = reinterpret_cast< wxImage * >(argp1);
16154 {
16155 PyThreadState* __tstate = wxPyBeginAllowThreads();
16156 result = (PyObject *)wxImage_GetAlphaData(arg1);
16157 wxPyEndAllowThreads(__tstate);
16158 if (PyErr_Occurred()) SWIG_fail;
16159 }
16160 resultobj = result;
16161 return resultobj;
16162 fail:
16163 return NULL;
16164 }
16165
16166
16167 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16168 PyObject *resultobj = 0;
16169 wxImage *arg1 = (wxImage *) 0 ;
16170 buffer arg2 ;
16171 int arg3 ;
16172 void *argp1 = 0 ;
16173 int res1 = 0 ;
16174 Py_ssize_t temp2 ;
16175 PyObject * obj0 = 0 ;
16176 PyObject * obj1 = 0 ;
16177 char * kwnames[] = {
16178 (char *) "self",(char *) "alpha", NULL
16179 };
16180
16181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
16182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16183 if (!SWIG_IsOK(res1)) {
16184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16185 }
16186 arg1 = reinterpret_cast< wxImage * >(argp1);
16187 {
16188 if (obj1 != Py_None) {
16189 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16190 arg3 = (int)temp2;
16191 }
16192 }
16193 {
16194 PyThreadState* __tstate = wxPyBeginAllowThreads();
16195 wxImage_SetAlphaData(arg1,arg2,arg3);
16196 wxPyEndAllowThreads(__tstate);
16197 if (PyErr_Occurred()) SWIG_fail;
16198 }
16199 resultobj = SWIG_Py_Void();
16200 return resultobj;
16201 fail:
16202 return NULL;
16203 }
16204
16205
16206 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16207 PyObject *resultobj = 0;
16208 wxImage *arg1 = (wxImage *) 0 ;
16209 PyObject *result = 0 ;
16210 void *argp1 = 0 ;
16211 int res1 = 0 ;
16212 PyObject *swig_obj[1] ;
16213
16214 if (!args) SWIG_fail;
16215 swig_obj[0] = args;
16216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16217 if (!SWIG_IsOK(res1)) {
16218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16219 }
16220 arg1 = reinterpret_cast< wxImage * >(argp1);
16221 {
16222 PyThreadState* __tstate = wxPyBeginAllowThreads();
16223 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
16224 wxPyEndAllowThreads(__tstate);
16225 if (PyErr_Occurred()) SWIG_fail;
16226 }
16227 resultobj = result;
16228 return resultobj;
16229 fail:
16230 return NULL;
16231 }
16232
16233
16234 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16235 PyObject *resultobj = 0;
16236 wxImage *arg1 = (wxImage *) 0 ;
16237 buffer arg2 ;
16238 int arg3 ;
16239 void *argp1 = 0 ;
16240 int res1 = 0 ;
16241 Py_ssize_t temp2 ;
16242 PyObject * obj0 = 0 ;
16243 PyObject * obj1 = 0 ;
16244 char * kwnames[] = {
16245 (char *) "self",(char *) "alpha", NULL
16246 };
16247
16248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16250 if (!SWIG_IsOK(res1)) {
16251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16252 }
16253 arg1 = reinterpret_cast< wxImage * >(argp1);
16254 {
16255 if (obj1 != Py_None) {
16256 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16257 arg3 = (int)temp2;
16258 }
16259 }
16260 {
16261 PyThreadState* __tstate = wxPyBeginAllowThreads();
16262 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
16263 wxPyEndAllowThreads(__tstate);
16264 if (PyErr_Occurred()) SWIG_fail;
16265 }
16266 resultobj = SWIG_Py_Void();
16267 return resultobj;
16268 fail:
16269 return NULL;
16270 }
16271
16272
16273 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16274 PyObject *resultobj = 0;
16275 wxImage *arg1 = (wxImage *) 0 ;
16276 byte arg2 ;
16277 byte arg3 ;
16278 byte arg4 ;
16279 void *argp1 = 0 ;
16280 int res1 = 0 ;
16281 unsigned char val2 ;
16282 int ecode2 = 0 ;
16283 unsigned char val3 ;
16284 int ecode3 = 0 ;
16285 unsigned char val4 ;
16286 int ecode4 = 0 ;
16287 PyObject * obj0 = 0 ;
16288 PyObject * obj1 = 0 ;
16289 PyObject * obj2 = 0 ;
16290 PyObject * obj3 = 0 ;
16291 char * kwnames[] = {
16292 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16293 };
16294
16295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16297 if (!SWIG_IsOK(res1)) {
16298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
16299 }
16300 arg1 = reinterpret_cast< wxImage * >(argp1);
16301 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16302 if (!SWIG_IsOK(ecode2)) {
16303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
16304 }
16305 arg2 = static_cast< byte >(val2);
16306 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16307 if (!SWIG_IsOK(ecode3)) {
16308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
16309 }
16310 arg3 = static_cast< byte >(val3);
16311 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16312 if (!SWIG_IsOK(ecode4)) {
16313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
16314 }
16315 arg4 = static_cast< byte >(val4);
16316 {
16317 PyThreadState* __tstate = wxPyBeginAllowThreads();
16318 (arg1)->SetMaskColour(arg2,arg3,arg4);
16319 wxPyEndAllowThreads(__tstate);
16320 if (PyErr_Occurred()) SWIG_fail;
16321 }
16322 resultobj = SWIG_Py_Void();
16323 return resultobj;
16324 fail:
16325 return NULL;
16326 }
16327
16328
16329 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16330 PyObject *resultobj = 0;
16331 wxImage *arg1 = (wxImage *) 0 ;
16332 byte *arg2 = (byte *) 0 ;
16333 byte *arg3 = (byte *) 0 ;
16334 byte *arg4 = (byte *) 0 ;
16335 void *argp1 = 0 ;
16336 int res1 = 0 ;
16337 byte temp2 ;
16338 int res2 = SWIG_TMPOBJ ;
16339 byte temp3 ;
16340 int res3 = SWIG_TMPOBJ ;
16341 byte temp4 ;
16342 int res4 = SWIG_TMPOBJ ;
16343 PyObject *swig_obj[1] ;
16344
16345 arg2 = &temp2;
16346 arg3 = &temp3;
16347 arg4 = &temp4;
16348 if (!args) SWIG_fail;
16349 swig_obj[0] = args;
16350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16351 if (!SWIG_IsOK(res1)) {
16352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
16353 }
16354 arg1 = reinterpret_cast< wxImage * >(argp1);
16355 {
16356 PyThreadState* __tstate = wxPyBeginAllowThreads();
16357 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
16358 wxPyEndAllowThreads(__tstate);
16359 if (PyErr_Occurred()) SWIG_fail;
16360 }
16361 resultobj = SWIG_Py_Void();
16362 if (SWIG_IsTmpObj(res2)) {
16363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
16364 } else {
16365 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16366 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
16367 }
16368 if (SWIG_IsTmpObj(res3)) {
16369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
16370 } else {
16371 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
16373 }
16374 if (SWIG_IsTmpObj(res4)) {
16375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
16376 } else {
16377 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
16379 }
16380 return resultobj;
16381 fail:
16382 return NULL;
16383 }
16384
16385
16386 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16387 PyObject *resultobj = 0;
16388 wxImage *arg1 = (wxImage *) 0 ;
16389 byte result;
16390 void *argp1 = 0 ;
16391 int res1 = 0 ;
16392 PyObject *swig_obj[1] ;
16393
16394 if (!args) SWIG_fail;
16395 swig_obj[0] = args;
16396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16397 if (!SWIG_IsOK(res1)) {
16398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
16399 }
16400 arg1 = reinterpret_cast< wxImage * >(argp1);
16401 {
16402 PyThreadState* __tstate = wxPyBeginAllowThreads();
16403 result = (byte)(arg1)->GetMaskRed();
16404 wxPyEndAllowThreads(__tstate);
16405 if (PyErr_Occurred()) SWIG_fail;
16406 }
16407 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16408 return resultobj;
16409 fail:
16410 return NULL;
16411 }
16412
16413
16414 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16415 PyObject *resultobj = 0;
16416 wxImage *arg1 = (wxImage *) 0 ;
16417 byte result;
16418 void *argp1 = 0 ;
16419 int res1 = 0 ;
16420 PyObject *swig_obj[1] ;
16421
16422 if (!args) SWIG_fail;
16423 swig_obj[0] = args;
16424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16425 if (!SWIG_IsOK(res1)) {
16426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16427 }
16428 arg1 = reinterpret_cast< wxImage * >(argp1);
16429 {
16430 PyThreadState* __tstate = wxPyBeginAllowThreads();
16431 result = (byte)(arg1)->GetMaskGreen();
16432 wxPyEndAllowThreads(__tstate);
16433 if (PyErr_Occurred()) SWIG_fail;
16434 }
16435 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16436 return resultobj;
16437 fail:
16438 return NULL;
16439 }
16440
16441
16442 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16443 PyObject *resultobj = 0;
16444 wxImage *arg1 = (wxImage *) 0 ;
16445 byte result;
16446 void *argp1 = 0 ;
16447 int res1 = 0 ;
16448 PyObject *swig_obj[1] ;
16449
16450 if (!args) SWIG_fail;
16451 swig_obj[0] = args;
16452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16453 if (!SWIG_IsOK(res1)) {
16454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16455 }
16456 arg1 = reinterpret_cast< wxImage * >(argp1);
16457 {
16458 PyThreadState* __tstate = wxPyBeginAllowThreads();
16459 result = (byte)(arg1)->GetMaskBlue();
16460 wxPyEndAllowThreads(__tstate);
16461 if (PyErr_Occurred()) SWIG_fail;
16462 }
16463 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16464 return resultobj;
16465 fail:
16466 return NULL;
16467 }
16468
16469
16470 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16471 PyObject *resultobj = 0;
16472 wxImage *arg1 = (wxImage *) 0 ;
16473 bool arg2 = (bool) true ;
16474 void *argp1 = 0 ;
16475 int res1 = 0 ;
16476 bool val2 ;
16477 int ecode2 = 0 ;
16478 PyObject * obj0 = 0 ;
16479 PyObject * obj1 = 0 ;
16480 char * kwnames[] = {
16481 (char *) "self",(char *) "mask", NULL
16482 };
16483
16484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
16485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16486 if (!SWIG_IsOK(res1)) {
16487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16488 }
16489 arg1 = reinterpret_cast< wxImage * >(argp1);
16490 if (obj1) {
16491 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16492 if (!SWIG_IsOK(ecode2)) {
16493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16494 }
16495 arg2 = static_cast< bool >(val2);
16496 }
16497 {
16498 PyThreadState* __tstate = wxPyBeginAllowThreads();
16499 (arg1)->SetMask(arg2);
16500 wxPyEndAllowThreads(__tstate);
16501 if (PyErr_Occurred()) SWIG_fail;
16502 }
16503 resultobj = SWIG_Py_Void();
16504 return resultobj;
16505 fail:
16506 return NULL;
16507 }
16508
16509
16510 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16511 PyObject *resultobj = 0;
16512 wxImage *arg1 = (wxImage *) 0 ;
16513 bool result;
16514 void *argp1 = 0 ;
16515 int res1 = 0 ;
16516 PyObject *swig_obj[1] ;
16517
16518 if (!args) SWIG_fail;
16519 swig_obj[0] = args;
16520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16521 if (!SWIG_IsOK(res1)) {
16522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16523 }
16524 arg1 = reinterpret_cast< wxImage * >(argp1);
16525 {
16526 PyThreadState* __tstate = wxPyBeginAllowThreads();
16527 result = (bool)(arg1)->HasMask();
16528 wxPyEndAllowThreads(__tstate);
16529 if (PyErr_Occurred()) SWIG_fail;
16530 }
16531 {
16532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16533 }
16534 return resultobj;
16535 fail:
16536 return NULL;
16537 }
16538
16539
16540 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16541 PyObject *resultobj = 0;
16542 wxImage *arg1 = (wxImage *) 0 ;
16543 double arg2 ;
16544 wxPoint *arg3 = 0 ;
16545 bool arg4 = (bool) true ;
16546 wxPoint *arg5 = (wxPoint *) NULL ;
16547 SwigValueWrapper<wxImage > result;
16548 void *argp1 = 0 ;
16549 int res1 = 0 ;
16550 double val2 ;
16551 int ecode2 = 0 ;
16552 wxPoint temp3 ;
16553 bool val4 ;
16554 int ecode4 = 0 ;
16555 void *argp5 = 0 ;
16556 int res5 = 0 ;
16557 PyObject * obj0 = 0 ;
16558 PyObject * obj1 = 0 ;
16559 PyObject * obj2 = 0 ;
16560 PyObject * obj3 = 0 ;
16561 PyObject * obj4 = 0 ;
16562 char * kwnames[] = {
16563 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16564 };
16565
16566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16568 if (!SWIG_IsOK(res1)) {
16569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16570 }
16571 arg1 = reinterpret_cast< wxImage * >(argp1);
16572 ecode2 = SWIG_AsVal_double(obj1, &val2);
16573 if (!SWIG_IsOK(ecode2)) {
16574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16575 }
16576 arg2 = static_cast< double >(val2);
16577 {
16578 arg3 = &temp3;
16579 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16580 }
16581 if (obj3) {
16582 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16583 if (!SWIG_IsOK(ecode4)) {
16584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16585 }
16586 arg4 = static_cast< bool >(val4);
16587 }
16588 if (obj4) {
16589 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16590 if (!SWIG_IsOK(res5)) {
16591 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16592 }
16593 arg5 = reinterpret_cast< wxPoint * >(argp5);
16594 }
16595 {
16596 PyThreadState* __tstate = wxPyBeginAllowThreads();
16597 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16598 wxPyEndAllowThreads(__tstate);
16599 if (PyErr_Occurred()) SWIG_fail;
16600 }
16601 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16602 return resultobj;
16603 fail:
16604 return NULL;
16605 }
16606
16607
16608 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16609 PyObject *resultobj = 0;
16610 wxImage *arg1 = (wxImage *) 0 ;
16611 bool arg2 = (bool) true ;
16612 SwigValueWrapper<wxImage > result;
16613 void *argp1 = 0 ;
16614 int res1 = 0 ;
16615 bool val2 ;
16616 int ecode2 = 0 ;
16617 PyObject * obj0 = 0 ;
16618 PyObject * obj1 = 0 ;
16619 char * kwnames[] = {
16620 (char *) "self",(char *) "clockwise", NULL
16621 };
16622
16623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16625 if (!SWIG_IsOK(res1)) {
16626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16627 }
16628 arg1 = reinterpret_cast< wxImage * >(argp1);
16629 if (obj1) {
16630 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16631 if (!SWIG_IsOK(ecode2)) {
16632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16633 }
16634 arg2 = static_cast< bool >(val2);
16635 }
16636 {
16637 PyThreadState* __tstate = wxPyBeginAllowThreads();
16638 result = (arg1)->Rotate90(arg2);
16639 wxPyEndAllowThreads(__tstate);
16640 if (PyErr_Occurred()) SWIG_fail;
16641 }
16642 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16643 return resultobj;
16644 fail:
16645 return NULL;
16646 }
16647
16648
16649 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16650 PyObject *resultobj = 0;
16651 wxImage *arg1 = (wxImage *) 0 ;
16652 bool arg2 = (bool) true ;
16653 SwigValueWrapper<wxImage > result;
16654 void *argp1 = 0 ;
16655 int res1 = 0 ;
16656 bool val2 ;
16657 int ecode2 = 0 ;
16658 PyObject * obj0 = 0 ;
16659 PyObject * obj1 = 0 ;
16660 char * kwnames[] = {
16661 (char *) "self",(char *) "horizontally", NULL
16662 };
16663
16664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16666 if (!SWIG_IsOK(res1)) {
16667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16668 }
16669 arg1 = reinterpret_cast< wxImage * >(argp1);
16670 if (obj1) {
16671 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16672 if (!SWIG_IsOK(ecode2)) {
16673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16674 }
16675 arg2 = static_cast< bool >(val2);
16676 }
16677 {
16678 PyThreadState* __tstate = wxPyBeginAllowThreads();
16679 result = (arg1)->Mirror(arg2);
16680 wxPyEndAllowThreads(__tstate);
16681 if (PyErr_Occurred()) SWIG_fail;
16682 }
16683 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16684 return resultobj;
16685 fail:
16686 return NULL;
16687 }
16688
16689
16690 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16691 PyObject *resultobj = 0;
16692 wxImage *arg1 = (wxImage *) 0 ;
16693 byte arg2 ;
16694 byte arg3 ;
16695 byte arg4 ;
16696 byte arg5 ;
16697 byte arg6 ;
16698 byte arg7 ;
16699 void *argp1 = 0 ;
16700 int res1 = 0 ;
16701 unsigned char val2 ;
16702 int ecode2 = 0 ;
16703 unsigned char val3 ;
16704 int ecode3 = 0 ;
16705 unsigned char val4 ;
16706 int ecode4 = 0 ;
16707 unsigned char val5 ;
16708 int ecode5 = 0 ;
16709 unsigned char val6 ;
16710 int ecode6 = 0 ;
16711 unsigned char val7 ;
16712 int ecode7 = 0 ;
16713 PyObject * obj0 = 0 ;
16714 PyObject * obj1 = 0 ;
16715 PyObject * obj2 = 0 ;
16716 PyObject * obj3 = 0 ;
16717 PyObject * obj4 = 0 ;
16718 PyObject * obj5 = 0 ;
16719 PyObject * obj6 = 0 ;
16720 char * kwnames[] = {
16721 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16722 };
16723
16724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16726 if (!SWIG_IsOK(res1)) {
16727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16728 }
16729 arg1 = reinterpret_cast< wxImage * >(argp1);
16730 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16731 if (!SWIG_IsOK(ecode2)) {
16732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16733 }
16734 arg2 = static_cast< byte >(val2);
16735 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16736 if (!SWIG_IsOK(ecode3)) {
16737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16738 }
16739 arg3 = static_cast< byte >(val3);
16740 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16741 if (!SWIG_IsOK(ecode4)) {
16742 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16743 }
16744 arg4 = static_cast< byte >(val4);
16745 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16746 if (!SWIG_IsOK(ecode5)) {
16747 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16748 }
16749 arg5 = static_cast< byte >(val5);
16750 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16751 if (!SWIG_IsOK(ecode6)) {
16752 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16753 }
16754 arg6 = static_cast< byte >(val6);
16755 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16756 if (!SWIG_IsOK(ecode7)) {
16757 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16758 }
16759 arg7 = static_cast< byte >(val7);
16760 {
16761 PyThreadState* __tstate = wxPyBeginAllowThreads();
16762 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16763 wxPyEndAllowThreads(__tstate);
16764 if (PyErr_Occurred()) SWIG_fail;
16765 }
16766 resultobj = SWIG_Py_Void();
16767 return resultobj;
16768 fail:
16769 return NULL;
16770 }
16771
16772
16773 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16774 PyObject *resultobj = 0;
16775 wxImage *arg1 = (wxImage *) 0 ;
16776 double arg2 = (double) 0.299 ;
16777 double arg3 = (double) 0.587 ;
16778 double arg4 = (double) 0.114 ;
16779 SwigValueWrapper<wxImage > result;
16780 void *argp1 = 0 ;
16781 int res1 = 0 ;
16782 double val2 ;
16783 int ecode2 = 0 ;
16784 double val3 ;
16785 int ecode3 = 0 ;
16786 double val4 ;
16787 int ecode4 = 0 ;
16788 PyObject * obj0 = 0 ;
16789 PyObject * obj1 = 0 ;
16790 PyObject * obj2 = 0 ;
16791 PyObject * obj3 = 0 ;
16792 char * kwnames[] = {
16793 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16794 };
16795
16796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16798 if (!SWIG_IsOK(res1)) {
16799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16800 }
16801 arg1 = reinterpret_cast< wxImage * >(argp1);
16802 if (obj1) {
16803 ecode2 = SWIG_AsVal_double(obj1, &val2);
16804 if (!SWIG_IsOK(ecode2)) {
16805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16806 }
16807 arg2 = static_cast< double >(val2);
16808 }
16809 if (obj2) {
16810 ecode3 = SWIG_AsVal_double(obj2, &val3);
16811 if (!SWIG_IsOK(ecode3)) {
16812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16813 }
16814 arg3 = static_cast< double >(val3);
16815 }
16816 if (obj3) {
16817 ecode4 = SWIG_AsVal_double(obj3, &val4);
16818 if (!SWIG_IsOK(ecode4)) {
16819 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16820 }
16821 arg4 = static_cast< double >(val4);
16822 }
16823 {
16824 PyThreadState* __tstate = wxPyBeginAllowThreads();
16825 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16826 wxPyEndAllowThreads(__tstate);
16827 if (PyErr_Occurred()) SWIG_fail;
16828 }
16829 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj = 0;
16838 wxImage *arg1 = (wxImage *) 0 ;
16839 byte arg2 ;
16840 byte arg3 ;
16841 byte arg4 ;
16842 SwigValueWrapper<wxImage > result;
16843 void *argp1 = 0 ;
16844 int res1 = 0 ;
16845 unsigned char val2 ;
16846 int ecode2 = 0 ;
16847 unsigned char val3 ;
16848 int ecode3 = 0 ;
16849 unsigned char val4 ;
16850 int ecode4 = 0 ;
16851 PyObject * obj0 = 0 ;
16852 PyObject * obj1 = 0 ;
16853 PyObject * obj2 = 0 ;
16854 PyObject * obj3 = 0 ;
16855 char * kwnames[] = {
16856 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16857 };
16858
16859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16861 if (!SWIG_IsOK(res1)) {
16862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16863 }
16864 arg1 = reinterpret_cast< wxImage * >(argp1);
16865 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16866 if (!SWIG_IsOK(ecode2)) {
16867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16868 }
16869 arg2 = static_cast< byte >(val2);
16870 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16871 if (!SWIG_IsOK(ecode3)) {
16872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16873 }
16874 arg3 = static_cast< byte >(val3);
16875 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16876 if (!SWIG_IsOK(ecode4)) {
16877 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16878 }
16879 arg4 = static_cast< byte >(val4);
16880 {
16881 PyThreadState* __tstate = wxPyBeginAllowThreads();
16882 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16883 wxPyEndAllowThreads(__tstate);
16884 if (PyErr_Occurred()) SWIG_fail;
16885 }
16886 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16887 return resultobj;
16888 fail:
16889 return NULL;
16890 }
16891
16892
16893 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16894 PyObject *resultobj = 0;
16895 wxImage *arg1 = (wxImage *) 0 ;
16896 wxString *arg2 = 0 ;
16897 wxString *arg3 = 0 ;
16898 void *argp1 = 0 ;
16899 int res1 = 0 ;
16900 bool temp2 = false ;
16901 bool temp3 = false ;
16902 PyObject * obj0 = 0 ;
16903 PyObject * obj1 = 0 ;
16904 PyObject * obj2 = 0 ;
16905 char * kwnames[] = {
16906 (char *) "self",(char *) "name",(char *) "value", NULL
16907 };
16908
16909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16911 if (!SWIG_IsOK(res1)) {
16912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16913 }
16914 arg1 = reinterpret_cast< wxImage * >(argp1);
16915 {
16916 arg2 = wxString_in_helper(obj1);
16917 if (arg2 == NULL) SWIG_fail;
16918 temp2 = true;
16919 }
16920 {
16921 arg3 = wxString_in_helper(obj2);
16922 if (arg3 == NULL) SWIG_fail;
16923 temp3 = true;
16924 }
16925 {
16926 PyThreadState* __tstate = wxPyBeginAllowThreads();
16927 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16928 wxPyEndAllowThreads(__tstate);
16929 if (PyErr_Occurred()) SWIG_fail;
16930 }
16931 resultobj = SWIG_Py_Void();
16932 {
16933 if (temp2)
16934 delete arg2;
16935 }
16936 {
16937 if (temp3)
16938 delete arg3;
16939 }
16940 return resultobj;
16941 fail:
16942 {
16943 if (temp2)
16944 delete arg2;
16945 }
16946 {
16947 if (temp3)
16948 delete arg3;
16949 }
16950 return NULL;
16951 }
16952
16953
16954 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16955 PyObject *resultobj = 0;
16956 wxImage *arg1 = (wxImage *) 0 ;
16957 wxString *arg2 = 0 ;
16958 int arg3 ;
16959 void *argp1 = 0 ;
16960 int res1 = 0 ;
16961 bool temp2 = false ;
16962 int val3 ;
16963 int ecode3 = 0 ;
16964 PyObject * obj0 = 0 ;
16965 PyObject * obj1 = 0 ;
16966 PyObject * obj2 = 0 ;
16967 char * kwnames[] = {
16968 (char *) "self",(char *) "name",(char *) "value", NULL
16969 };
16970
16971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16973 if (!SWIG_IsOK(res1)) {
16974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16975 }
16976 arg1 = reinterpret_cast< wxImage * >(argp1);
16977 {
16978 arg2 = wxString_in_helper(obj1);
16979 if (arg2 == NULL) SWIG_fail;
16980 temp2 = true;
16981 }
16982 ecode3 = SWIG_AsVal_int(obj2, &val3);
16983 if (!SWIG_IsOK(ecode3)) {
16984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16985 }
16986 arg3 = static_cast< int >(val3);
16987 {
16988 PyThreadState* __tstate = wxPyBeginAllowThreads();
16989 (arg1)->SetOption((wxString const &)*arg2,arg3);
16990 wxPyEndAllowThreads(__tstate);
16991 if (PyErr_Occurred()) SWIG_fail;
16992 }
16993 resultobj = SWIG_Py_Void();
16994 {
16995 if (temp2)
16996 delete arg2;
16997 }
16998 return resultobj;
16999 fail:
17000 {
17001 if (temp2)
17002 delete arg2;
17003 }
17004 return NULL;
17005 }
17006
17007
17008 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17009 PyObject *resultobj = 0;
17010 wxImage *arg1 = (wxImage *) 0 ;
17011 wxString *arg2 = 0 ;
17012 wxString result;
17013 void *argp1 = 0 ;
17014 int res1 = 0 ;
17015 bool temp2 = false ;
17016 PyObject * obj0 = 0 ;
17017 PyObject * obj1 = 0 ;
17018 char * kwnames[] = {
17019 (char *) "self",(char *) "name", NULL
17020 };
17021
17022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
17023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17024 if (!SWIG_IsOK(res1)) {
17025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17026 }
17027 arg1 = reinterpret_cast< wxImage * >(argp1);
17028 {
17029 arg2 = wxString_in_helper(obj1);
17030 if (arg2 == NULL) SWIG_fail;
17031 temp2 = true;
17032 }
17033 {
17034 PyThreadState* __tstate = wxPyBeginAllowThreads();
17035 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
17036 wxPyEndAllowThreads(__tstate);
17037 if (PyErr_Occurred()) SWIG_fail;
17038 }
17039 {
17040 #if wxUSE_UNICODE
17041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17042 #else
17043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17044 #endif
17045 }
17046 {
17047 if (temp2)
17048 delete arg2;
17049 }
17050 return resultobj;
17051 fail:
17052 {
17053 if (temp2)
17054 delete arg2;
17055 }
17056 return NULL;
17057 }
17058
17059
17060 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17061 PyObject *resultobj = 0;
17062 wxImage *arg1 = (wxImage *) 0 ;
17063 wxString *arg2 = 0 ;
17064 int result;
17065 void *argp1 = 0 ;
17066 int res1 = 0 ;
17067 bool temp2 = false ;
17068 PyObject * obj0 = 0 ;
17069 PyObject * obj1 = 0 ;
17070 char * kwnames[] = {
17071 (char *) "self",(char *) "name", NULL
17072 };
17073
17074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
17075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17076 if (!SWIG_IsOK(res1)) {
17077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
17078 }
17079 arg1 = reinterpret_cast< wxImage * >(argp1);
17080 {
17081 arg2 = wxString_in_helper(obj1);
17082 if (arg2 == NULL) SWIG_fail;
17083 temp2 = true;
17084 }
17085 {
17086 PyThreadState* __tstate = wxPyBeginAllowThreads();
17087 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
17088 wxPyEndAllowThreads(__tstate);
17089 if (PyErr_Occurred()) SWIG_fail;
17090 }
17091 resultobj = SWIG_From_int(static_cast< int >(result));
17092 {
17093 if (temp2)
17094 delete arg2;
17095 }
17096 return resultobj;
17097 fail:
17098 {
17099 if (temp2)
17100 delete arg2;
17101 }
17102 return NULL;
17103 }
17104
17105
17106 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17107 PyObject *resultobj = 0;
17108 wxImage *arg1 = (wxImage *) 0 ;
17109 wxString *arg2 = 0 ;
17110 bool result;
17111 void *argp1 = 0 ;
17112 int res1 = 0 ;
17113 bool temp2 = false ;
17114 PyObject * obj0 = 0 ;
17115 PyObject * obj1 = 0 ;
17116 char * kwnames[] = {
17117 (char *) "self",(char *) "name", NULL
17118 };
17119
17120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
17121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17122 if (!SWIG_IsOK(res1)) {
17123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17124 }
17125 arg1 = reinterpret_cast< wxImage * >(argp1);
17126 {
17127 arg2 = wxString_in_helper(obj1);
17128 if (arg2 == NULL) SWIG_fail;
17129 temp2 = true;
17130 }
17131 {
17132 PyThreadState* __tstate = wxPyBeginAllowThreads();
17133 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
17134 wxPyEndAllowThreads(__tstate);
17135 if (PyErr_Occurred()) SWIG_fail;
17136 }
17137 {
17138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17139 }
17140 {
17141 if (temp2)
17142 delete arg2;
17143 }
17144 return resultobj;
17145 fail:
17146 {
17147 if (temp2)
17148 delete arg2;
17149 }
17150 return NULL;
17151 }
17152
17153
17154 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17155 PyObject *resultobj = 0;
17156 wxImage *arg1 = (wxImage *) 0 ;
17157 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
17158 unsigned long result;
17159 void *argp1 = 0 ;
17160 int res1 = 0 ;
17161 unsigned long val2 ;
17162 int ecode2 = 0 ;
17163 PyObject * obj0 = 0 ;
17164 PyObject * obj1 = 0 ;
17165 char * kwnames[] = {
17166 (char *) "self",(char *) "stopafter", NULL
17167 };
17168
17169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
17170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17171 if (!SWIG_IsOK(res1)) {
17172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
17173 }
17174 arg1 = reinterpret_cast< wxImage * >(argp1);
17175 if (obj1) {
17176 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
17177 if (!SWIG_IsOK(ecode2)) {
17178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
17179 }
17180 arg2 = static_cast< unsigned long >(val2);
17181 }
17182 {
17183 PyThreadState* __tstate = wxPyBeginAllowThreads();
17184 result = (unsigned long)(arg1)->CountColours(arg2);
17185 wxPyEndAllowThreads(__tstate);
17186 if (PyErr_Occurred()) SWIG_fail;
17187 }
17188 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17189 return resultobj;
17190 fail:
17191 return NULL;
17192 }
17193
17194
17195 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17196 PyObject *resultobj = 0;
17197 wxImage *arg1 = (wxImage *) 0 ;
17198 wxImageHistogram *arg2 = 0 ;
17199 unsigned long result;
17200 void *argp1 = 0 ;
17201 int res1 = 0 ;
17202 void *argp2 = 0 ;
17203 int res2 = 0 ;
17204 PyObject * obj0 = 0 ;
17205 PyObject * obj1 = 0 ;
17206 char * kwnames[] = {
17207 (char *) "self",(char *) "h", NULL
17208 };
17209
17210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
17211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17212 if (!SWIG_IsOK(res1)) {
17213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
17214 }
17215 arg1 = reinterpret_cast< wxImage * >(argp1);
17216 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
17217 if (!SWIG_IsOK(res2)) {
17218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17219 }
17220 if (!argp2) {
17221 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17222 }
17223 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
17224 {
17225 PyThreadState* __tstate = wxPyBeginAllowThreads();
17226 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
17227 wxPyEndAllowThreads(__tstate);
17228 if (PyErr_Occurred()) SWIG_fail;
17229 }
17230 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17231 return resultobj;
17232 fail:
17233 return NULL;
17234 }
17235
17236
17237 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17238 PyObject *resultobj = 0;
17239 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17240 void *argp1 = 0 ;
17241 int res1 = 0 ;
17242 PyObject * obj0 = 0 ;
17243 char * kwnames[] = {
17244 (char *) "handler", NULL
17245 };
17246
17247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
17248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17249 if (!SWIG_IsOK(res1)) {
17250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17251 }
17252 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17253 {
17254 PyThreadState* __tstate = wxPyBeginAllowThreads();
17255 wxImage::AddHandler(arg1);
17256 wxPyEndAllowThreads(__tstate);
17257 if (PyErr_Occurred()) SWIG_fail;
17258 }
17259 resultobj = SWIG_Py_Void();
17260 return resultobj;
17261 fail:
17262 return NULL;
17263 }
17264
17265
17266 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17267 PyObject *resultobj = 0;
17268 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17269 void *argp1 = 0 ;
17270 int res1 = 0 ;
17271 PyObject * obj0 = 0 ;
17272 char * kwnames[] = {
17273 (char *) "handler", NULL
17274 };
17275
17276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
17277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17278 if (!SWIG_IsOK(res1)) {
17279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17280 }
17281 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17282 {
17283 PyThreadState* __tstate = wxPyBeginAllowThreads();
17284 wxImage::InsertHandler(arg1);
17285 wxPyEndAllowThreads(__tstate);
17286 if (PyErr_Occurred()) SWIG_fail;
17287 }
17288 resultobj = SWIG_Py_Void();
17289 return resultobj;
17290 fail:
17291 return NULL;
17292 }
17293
17294
17295 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17296 PyObject *resultobj = 0;
17297 wxString *arg1 = 0 ;
17298 bool result;
17299 bool temp1 = false ;
17300 PyObject * obj0 = 0 ;
17301 char * kwnames[] = {
17302 (char *) "name", NULL
17303 };
17304
17305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
17306 {
17307 arg1 = wxString_in_helper(obj0);
17308 if (arg1 == NULL) SWIG_fail;
17309 temp1 = true;
17310 }
17311 {
17312 PyThreadState* __tstate = wxPyBeginAllowThreads();
17313 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
17314 wxPyEndAllowThreads(__tstate);
17315 if (PyErr_Occurred()) SWIG_fail;
17316 }
17317 {
17318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17319 }
17320 {
17321 if (temp1)
17322 delete arg1;
17323 }
17324 return resultobj;
17325 fail:
17326 {
17327 if (temp1)
17328 delete arg1;
17329 }
17330 return NULL;
17331 }
17332
17333
17334 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17335 PyObject *resultobj = 0;
17336 PyObject *result = 0 ;
17337
17338 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
17339 {
17340 PyThreadState* __tstate = wxPyBeginAllowThreads();
17341 result = (PyObject *)wxImage_GetHandlers();
17342 wxPyEndAllowThreads(__tstate);
17343 if (PyErr_Occurred()) SWIG_fail;
17344 }
17345 resultobj = result;
17346 return resultobj;
17347 fail:
17348 return NULL;
17349 }
17350
17351
17352 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17353 PyObject *resultobj = 0;
17354 wxString result;
17355
17356 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
17357 {
17358 PyThreadState* __tstate = wxPyBeginAllowThreads();
17359 result = wxImage::GetImageExtWildcard();
17360 wxPyEndAllowThreads(__tstate);
17361 if (PyErr_Occurred()) SWIG_fail;
17362 }
17363 {
17364 #if wxUSE_UNICODE
17365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17366 #else
17367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17368 #endif
17369 }
17370 return resultobj;
17371 fail:
17372 return NULL;
17373 }
17374
17375
17376 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17377 PyObject *resultobj = 0;
17378 wxImage *arg1 = (wxImage *) 0 ;
17379 int arg2 = (int) -1 ;
17380 wxBitmap result;
17381 void *argp1 = 0 ;
17382 int res1 = 0 ;
17383 int val2 ;
17384 int ecode2 = 0 ;
17385 PyObject * obj0 = 0 ;
17386 PyObject * obj1 = 0 ;
17387 char * kwnames[] = {
17388 (char *) "self",(char *) "depth", NULL
17389 };
17390
17391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
17392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17393 if (!SWIG_IsOK(res1)) {
17394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17395 }
17396 arg1 = reinterpret_cast< wxImage * >(argp1);
17397 if (obj1) {
17398 ecode2 = SWIG_AsVal_int(obj1, &val2);
17399 if (!SWIG_IsOK(ecode2)) {
17400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
17401 }
17402 arg2 = static_cast< int >(val2);
17403 }
17404 {
17405 if (!wxPyCheckForApp()) SWIG_fail;
17406 PyThreadState* __tstate = wxPyBeginAllowThreads();
17407 result = wxImage_ConvertToBitmap(arg1,arg2);
17408 wxPyEndAllowThreads(__tstate);
17409 if (PyErr_Occurred()) SWIG_fail;
17410 }
17411 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17412 return resultobj;
17413 fail:
17414 return NULL;
17415 }
17416
17417
17418 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17419 PyObject *resultobj = 0;
17420 wxImage *arg1 = (wxImage *) 0 ;
17421 byte arg2 ;
17422 byte arg3 ;
17423 byte arg4 ;
17424 wxBitmap result;
17425 void *argp1 = 0 ;
17426 int res1 = 0 ;
17427 unsigned char val2 ;
17428 int ecode2 = 0 ;
17429 unsigned char val3 ;
17430 int ecode3 = 0 ;
17431 unsigned char val4 ;
17432 int ecode4 = 0 ;
17433 PyObject * obj0 = 0 ;
17434 PyObject * obj1 = 0 ;
17435 PyObject * obj2 = 0 ;
17436 PyObject * obj3 = 0 ;
17437 char * kwnames[] = {
17438 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
17439 };
17440
17441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17443 if (!SWIG_IsOK(res1)) {
17444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17445 }
17446 arg1 = reinterpret_cast< wxImage * >(argp1);
17447 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17448 if (!SWIG_IsOK(ecode2)) {
17449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
17450 }
17451 arg2 = static_cast< byte >(val2);
17452 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17453 if (!SWIG_IsOK(ecode3)) {
17454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
17455 }
17456 arg3 = static_cast< byte >(val3);
17457 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17458 if (!SWIG_IsOK(ecode4)) {
17459 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
17460 }
17461 arg4 = static_cast< byte >(val4);
17462 {
17463 if (!wxPyCheckForApp()) SWIG_fail;
17464 PyThreadState* __tstate = wxPyBeginAllowThreads();
17465 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
17466 wxPyEndAllowThreads(__tstate);
17467 if (PyErr_Occurred()) SWIG_fail;
17468 }
17469 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17470 return resultobj;
17471 fail:
17472 return NULL;
17473 }
17474
17475
17476 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17477 PyObject *resultobj = 0;
17478 wxImage *arg1 = (wxImage *) 0 ;
17479 double arg2 ;
17480 void *argp1 = 0 ;
17481 int res1 = 0 ;
17482 double val2 ;
17483 int ecode2 = 0 ;
17484 PyObject * obj0 = 0 ;
17485 PyObject * obj1 = 0 ;
17486 char * kwnames[] = {
17487 (char *) "self",(char *) "angle", NULL
17488 };
17489
17490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17492 if (!SWIG_IsOK(res1)) {
17493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17494 }
17495 arg1 = reinterpret_cast< wxImage * >(argp1);
17496 ecode2 = SWIG_AsVal_double(obj1, &val2);
17497 if (!SWIG_IsOK(ecode2)) {
17498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17499 }
17500 arg2 = static_cast< double >(val2);
17501 {
17502 PyThreadState* __tstate = wxPyBeginAllowThreads();
17503 (arg1)->RotateHue(arg2);
17504 wxPyEndAllowThreads(__tstate);
17505 if (PyErr_Occurred()) SWIG_fail;
17506 }
17507 resultobj = SWIG_Py_Void();
17508 return resultobj;
17509 fail:
17510 return NULL;
17511 }
17512
17513
17514 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17515 PyObject *resultobj = 0;
17516 wxImage_RGBValue arg1 ;
17517 wxImage_HSVValue result;
17518 void *argp1 ;
17519 int res1 = 0 ;
17520 PyObject * obj0 = 0 ;
17521 char * kwnames[] = {
17522 (char *) "rgb", NULL
17523 };
17524
17525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17526 {
17527 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17528 if (!SWIG_IsOK(res1)) {
17529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17530 }
17531 if (!argp1) {
17532 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17533 } else {
17534 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17535 arg1 = *temp;
17536 if (SWIG_IsNewObj(res1)) delete temp;
17537 }
17538 }
17539 {
17540 PyThreadState* __tstate = wxPyBeginAllowThreads();
17541 result = wxImage::RGBtoHSV(arg1);
17542 wxPyEndAllowThreads(__tstate);
17543 if (PyErr_Occurred()) SWIG_fail;
17544 }
17545 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17546 return resultobj;
17547 fail:
17548 return NULL;
17549 }
17550
17551
17552 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17553 PyObject *resultobj = 0;
17554 wxImage_HSVValue arg1 ;
17555 wxImage_RGBValue result;
17556 void *argp1 ;
17557 int res1 = 0 ;
17558 PyObject * obj0 = 0 ;
17559 char * kwnames[] = {
17560 (char *) "hsv", NULL
17561 };
17562
17563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17564 {
17565 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17566 if (!SWIG_IsOK(res1)) {
17567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17568 }
17569 if (!argp1) {
17570 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17571 } else {
17572 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17573 arg1 = *temp;
17574 if (SWIG_IsNewObj(res1)) delete temp;
17575 }
17576 }
17577 {
17578 PyThreadState* __tstate = wxPyBeginAllowThreads();
17579 result = wxImage::HSVtoRGB(arg1);
17580 wxPyEndAllowThreads(__tstate);
17581 if (PyErr_Occurred()) SWIG_fail;
17582 }
17583 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17584 return resultobj;
17585 fail:
17586 return NULL;
17587 }
17588
17589
17590 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17591 PyObject *obj;
17592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17593 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17594 return SWIG_Py_Void();
17595 }
17596
17597 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17598 return SWIG_Python_InitShadowInstance(args);
17599 }
17600
17601 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17602 PyObject *resultobj = 0;
17603 int arg1 ;
17604 int arg2 ;
17605 buffer arg3 ;
17606 int arg4 ;
17607 buffer arg5 = (buffer) NULL ;
17608 int arg6 = (int) 0 ;
17609 wxImage *result = 0 ;
17610 int val1 ;
17611 int ecode1 = 0 ;
17612 int val2 ;
17613 int ecode2 = 0 ;
17614 Py_ssize_t temp3 ;
17615 Py_ssize_t temp5 ;
17616 PyObject * obj0 = 0 ;
17617 PyObject * obj1 = 0 ;
17618 PyObject * obj2 = 0 ;
17619 PyObject * obj3 = 0 ;
17620 char * kwnames[] = {
17621 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17622 };
17623
17624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17625 ecode1 = SWIG_AsVal_int(obj0, &val1);
17626 if (!SWIG_IsOK(ecode1)) {
17627 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17628 }
17629 arg1 = static_cast< int >(val1);
17630 ecode2 = SWIG_AsVal_int(obj1, &val2);
17631 if (!SWIG_IsOK(ecode2)) {
17632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17633 }
17634 arg2 = static_cast< int >(val2);
17635 {
17636 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17637 arg4 = (int)temp3;
17638 }
17639 if (obj3) {
17640 {
17641 if (obj3 != Py_None) {
17642 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17643 arg6 = (int)temp5;
17644 }
17645 }
17646 }
17647 {
17648 PyThreadState* __tstate = wxPyBeginAllowThreads();
17649 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17650 wxPyEndAllowThreads(__tstate);
17651 if (PyErr_Occurred()) SWIG_fail;
17652 }
17653 {
17654 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17655 }
17656 return resultobj;
17657 fail:
17658 return NULL;
17659 }
17660
17661
17662 SWIGINTERN int NullImage_set(PyObject *) {
17663 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17664 return 1;
17665 }
17666
17667
17668 SWIGINTERN PyObject *NullImage_get(void) {
17669 PyObject *pyobj = 0;
17670
17671 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17672 return pyobj;
17673 }
17674
17675
17676 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17677 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17678 return 1;
17679 }
17680
17681
17682 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17683 PyObject *pyobj = 0;
17684
17685 {
17686 #if wxUSE_UNICODE
17687 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17688 #else
17689 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17690 #endif
17691 }
17692 return pyobj;
17693 }
17694
17695
17696 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17697 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17698 return 1;
17699 }
17700
17701
17702 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17703 PyObject *pyobj = 0;
17704
17705 {
17706 #if wxUSE_UNICODE
17707 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17708 #else
17709 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17710 #endif
17711 }
17712 return pyobj;
17713 }
17714
17715
17716 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17717 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17718 return 1;
17719 }
17720
17721
17722 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17723 PyObject *pyobj = 0;
17724
17725 {
17726 #if wxUSE_UNICODE
17727 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17728 #else
17729 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17730 #endif
17731 }
17732 return pyobj;
17733 }
17734
17735
17736 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17737 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17738 return 1;
17739 }
17740
17741
17742 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17743 PyObject *pyobj = 0;
17744
17745 {
17746 #if wxUSE_UNICODE
17747 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17748 #else
17749 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17750 #endif
17751 }
17752 return pyobj;
17753 }
17754
17755
17756 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17757 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17758 return 1;
17759 }
17760
17761
17762 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17763 PyObject *pyobj = 0;
17764
17765 {
17766 #if wxUSE_UNICODE
17767 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17768 #else
17769 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17770 #endif
17771 }
17772 return pyobj;
17773 }
17774
17775
17776 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17777 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17778 return 1;
17779 }
17780
17781
17782 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17783 PyObject *pyobj = 0;
17784
17785 {
17786 #if wxUSE_UNICODE
17787 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17788 #else
17789 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17790 #endif
17791 }
17792 return pyobj;
17793 }
17794
17795
17796 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17797 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17798 return 1;
17799 }
17800
17801
17802 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17803 PyObject *pyobj = 0;
17804
17805 {
17806 #if wxUSE_UNICODE
17807 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17808 #else
17809 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17810 #endif
17811 }
17812 return pyobj;
17813 }
17814
17815
17816 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17817 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17818 return 1;
17819 }
17820
17821
17822 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17823 PyObject *pyobj = 0;
17824
17825 {
17826 #if wxUSE_UNICODE
17827 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17828 #else
17829 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17830 #endif
17831 }
17832 return pyobj;
17833 }
17834
17835
17836 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17837 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17838 return 1;
17839 }
17840
17841
17842 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17843 PyObject *pyobj = 0;
17844
17845 {
17846 #if wxUSE_UNICODE
17847 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17848 #else
17849 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17850 #endif
17851 }
17852 return pyobj;
17853 }
17854
17855
17856 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17857 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17858 return 1;
17859 }
17860
17861
17862 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17863 PyObject *pyobj = 0;
17864
17865 {
17866 #if wxUSE_UNICODE
17867 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17868 #else
17869 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17870 #endif
17871 }
17872 return pyobj;
17873 }
17874
17875
17876 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17877 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17878 return 1;
17879 }
17880
17881
17882 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17883 PyObject *pyobj = 0;
17884
17885 {
17886 #if wxUSE_UNICODE
17887 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17888 #else
17889 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17890 #endif
17891 }
17892 return pyobj;
17893 }
17894
17895
17896 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17897 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17898 return 1;
17899 }
17900
17901
17902 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17903 PyObject *pyobj = 0;
17904
17905 {
17906 #if wxUSE_UNICODE
17907 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17908 #else
17909 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17910 #endif
17911 }
17912 return pyobj;
17913 }
17914
17915
17916 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17917 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17918 return 1;
17919 }
17920
17921
17922 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17923 PyObject *pyobj = 0;
17924
17925 {
17926 #if wxUSE_UNICODE
17927 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17928 #else
17929 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17930 #endif
17931 }
17932 return pyobj;
17933 }
17934
17935
17936 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17937 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17938 return 1;
17939 }
17940
17941
17942 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17943 PyObject *pyobj = 0;
17944
17945 {
17946 #if wxUSE_UNICODE
17947 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17948 #else
17949 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17950 #endif
17951 }
17952 return pyobj;
17953 }
17954
17955
17956 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17957 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17958 return 1;
17959 }
17960
17961
17962 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17963 PyObject *pyobj = 0;
17964
17965 {
17966 #if wxUSE_UNICODE
17967 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17968 #else
17969 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17970 #endif
17971 }
17972 return pyobj;
17973 }
17974
17975
17976 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17977 PyObject *resultobj = 0;
17978 wxBMPHandler *result = 0 ;
17979
17980 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17981 {
17982 PyThreadState* __tstate = wxPyBeginAllowThreads();
17983 result = (wxBMPHandler *)new wxBMPHandler();
17984 wxPyEndAllowThreads(__tstate);
17985 if (PyErr_Occurred()) SWIG_fail;
17986 }
17987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17988 return resultobj;
17989 fail:
17990 return NULL;
17991 }
17992
17993
17994 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17995 PyObject *obj;
17996 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17997 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17998 return SWIG_Py_Void();
17999 }
18000
18001 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18002 return SWIG_Python_InitShadowInstance(args);
18003 }
18004
18005 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18006 PyObject *resultobj = 0;
18007 wxICOHandler *result = 0 ;
18008
18009 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
18010 {
18011 PyThreadState* __tstate = wxPyBeginAllowThreads();
18012 result = (wxICOHandler *)new wxICOHandler();
18013 wxPyEndAllowThreads(__tstate);
18014 if (PyErr_Occurred()) SWIG_fail;
18015 }
18016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
18017 return resultobj;
18018 fail:
18019 return NULL;
18020 }
18021
18022
18023 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18024 PyObject *obj;
18025 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18026 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
18027 return SWIG_Py_Void();
18028 }
18029
18030 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18031 return SWIG_Python_InitShadowInstance(args);
18032 }
18033
18034 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18035 PyObject *resultobj = 0;
18036 wxCURHandler *result = 0 ;
18037
18038 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
18039 {
18040 PyThreadState* __tstate = wxPyBeginAllowThreads();
18041 result = (wxCURHandler *)new wxCURHandler();
18042 wxPyEndAllowThreads(__tstate);
18043 if (PyErr_Occurred()) SWIG_fail;
18044 }
18045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
18046 return resultobj;
18047 fail:
18048 return NULL;
18049 }
18050
18051
18052 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18053 PyObject *obj;
18054 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18055 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
18056 return SWIG_Py_Void();
18057 }
18058
18059 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18060 return SWIG_Python_InitShadowInstance(args);
18061 }
18062
18063 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18064 PyObject *resultobj = 0;
18065 wxANIHandler *result = 0 ;
18066
18067 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
18068 {
18069 PyThreadState* __tstate = wxPyBeginAllowThreads();
18070 result = (wxANIHandler *)new wxANIHandler();
18071 wxPyEndAllowThreads(__tstate);
18072 if (PyErr_Occurred()) SWIG_fail;
18073 }
18074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
18075 return resultobj;
18076 fail:
18077 return NULL;
18078 }
18079
18080
18081 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18082 PyObject *obj;
18083 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18084 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
18085 return SWIG_Py_Void();
18086 }
18087
18088 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18089 return SWIG_Python_InitShadowInstance(args);
18090 }
18091
18092 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18093 PyObject *resultobj = 0;
18094 wxPNGHandler *result = 0 ;
18095
18096 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
18097 {
18098 PyThreadState* __tstate = wxPyBeginAllowThreads();
18099 result = (wxPNGHandler *)new wxPNGHandler();
18100 wxPyEndAllowThreads(__tstate);
18101 if (PyErr_Occurred()) SWIG_fail;
18102 }
18103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
18104 return resultobj;
18105 fail:
18106 return NULL;
18107 }
18108
18109
18110 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18111 PyObject *obj;
18112 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18113 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
18114 return SWIG_Py_Void();
18115 }
18116
18117 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18118 return SWIG_Python_InitShadowInstance(args);
18119 }
18120
18121 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18122 PyObject *resultobj = 0;
18123 wxGIFHandler *result = 0 ;
18124
18125 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
18126 {
18127 PyThreadState* __tstate = wxPyBeginAllowThreads();
18128 result = (wxGIFHandler *)new wxGIFHandler();
18129 wxPyEndAllowThreads(__tstate);
18130 if (PyErr_Occurred()) SWIG_fail;
18131 }
18132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
18133 return resultobj;
18134 fail:
18135 return NULL;
18136 }
18137
18138
18139 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18140 PyObject *obj;
18141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18142 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
18143 return SWIG_Py_Void();
18144 }
18145
18146 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18147 return SWIG_Python_InitShadowInstance(args);
18148 }
18149
18150 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18151 PyObject *resultobj = 0;
18152 wxPCXHandler *result = 0 ;
18153
18154 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
18155 {
18156 PyThreadState* __tstate = wxPyBeginAllowThreads();
18157 result = (wxPCXHandler *)new wxPCXHandler();
18158 wxPyEndAllowThreads(__tstate);
18159 if (PyErr_Occurred()) SWIG_fail;
18160 }
18161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
18162 return resultobj;
18163 fail:
18164 return NULL;
18165 }
18166
18167
18168 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18169 PyObject *obj;
18170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18171 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
18172 return SWIG_Py_Void();
18173 }
18174
18175 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18176 return SWIG_Python_InitShadowInstance(args);
18177 }
18178
18179 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18180 PyObject *resultobj = 0;
18181 wxJPEGHandler *result = 0 ;
18182
18183 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
18184 {
18185 PyThreadState* __tstate = wxPyBeginAllowThreads();
18186 result = (wxJPEGHandler *)new wxJPEGHandler();
18187 wxPyEndAllowThreads(__tstate);
18188 if (PyErr_Occurred()) SWIG_fail;
18189 }
18190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
18191 return resultobj;
18192 fail:
18193 return NULL;
18194 }
18195
18196
18197 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18198 PyObject *obj;
18199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18200 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
18201 return SWIG_Py_Void();
18202 }
18203
18204 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18205 return SWIG_Python_InitShadowInstance(args);
18206 }
18207
18208 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18209 PyObject *resultobj = 0;
18210 wxPNMHandler *result = 0 ;
18211
18212 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
18213 {
18214 PyThreadState* __tstate = wxPyBeginAllowThreads();
18215 result = (wxPNMHandler *)new wxPNMHandler();
18216 wxPyEndAllowThreads(__tstate);
18217 if (PyErr_Occurred()) SWIG_fail;
18218 }
18219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
18220 return resultobj;
18221 fail:
18222 return NULL;
18223 }
18224
18225
18226 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18227 PyObject *obj;
18228 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18229 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
18230 return SWIG_Py_Void();
18231 }
18232
18233 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18234 return SWIG_Python_InitShadowInstance(args);
18235 }
18236
18237 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18238 PyObject *resultobj = 0;
18239 wxXPMHandler *result = 0 ;
18240
18241 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
18242 {
18243 PyThreadState* __tstate = wxPyBeginAllowThreads();
18244 result = (wxXPMHandler *)new wxXPMHandler();
18245 wxPyEndAllowThreads(__tstate);
18246 if (PyErr_Occurred()) SWIG_fail;
18247 }
18248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
18249 return resultobj;
18250 fail:
18251 return NULL;
18252 }
18253
18254
18255 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18256 PyObject *obj;
18257 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18258 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
18259 return SWIG_Py_Void();
18260 }
18261
18262 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18263 return SWIG_Python_InitShadowInstance(args);
18264 }
18265
18266 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18267 PyObject *resultobj = 0;
18268 wxTIFFHandler *result = 0 ;
18269
18270 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
18271 {
18272 PyThreadState* __tstate = wxPyBeginAllowThreads();
18273 result = (wxTIFFHandler *)new wxTIFFHandler();
18274 wxPyEndAllowThreads(__tstate);
18275 if (PyErr_Occurred()) SWIG_fail;
18276 }
18277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
18278 return resultobj;
18279 fail:
18280 return NULL;
18281 }
18282
18283
18284 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18285 PyObject *obj;
18286 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18287 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
18288 return SWIG_Py_Void();
18289 }
18290
18291 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18292 return SWIG_Python_InitShadowInstance(args);
18293 }
18294
18295 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18296 PyObject *resultobj = 0;
18297 wxImage *arg1 = 0 ;
18298 wxImage *arg2 = 0 ;
18299 int arg3 = (int) 236 ;
18300 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
18301 bool result;
18302 void *argp1 = 0 ;
18303 int res1 = 0 ;
18304 void *argp2 = 0 ;
18305 int res2 = 0 ;
18306 int val3 ;
18307 int ecode3 = 0 ;
18308 int val4 ;
18309 int ecode4 = 0 ;
18310 PyObject * obj0 = 0 ;
18311 PyObject * obj1 = 0 ;
18312 PyObject * obj2 = 0 ;
18313 PyObject * obj3 = 0 ;
18314 char * kwnames[] = {
18315 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
18316 };
18317
18318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18319 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
18320 if (!SWIG_IsOK(res1)) {
18321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18322 }
18323 if (!argp1) {
18324 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18325 }
18326 arg1 = reinterpret_cast< wxImage * >(argp1);
18327 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
18328 if (!SWIG_IsOK(res2)) {
18329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18330 }
18331 if (!argp2) {
18332 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18333 }
18334 arg2 = reinterpret_cast< wxImage * >(argp2);
18335 if (obj2) {
18336 ecode3 = SWIG_AsVal_int(obj2, &val3);
18337 if (!SWIG_IsOK(ecode3)) {
18338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
18339 }
18340 arg3 = static_cast< int >(val3);
18341 }
18342 if (obj3) {
18343 ecode4 = SWIG_AsVal_int(obj3, &val4);
18344 if (!SWIG_IsOK(ecode4)) {
18345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
18346 }
18347 arg4 = static_cast< int >(val4);
18348 }
18349 {
18350 PyThreadState* __tstate = wxPyBeginAllowThreads();
18351 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
18352 wxPyEndAllowThreads(__tstate);
18353 if (PyErr_Occurred()) SWIG_fail;
18354 }
18355 {
18356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18357 }
18358 return resultobj;
18359 fail:
18360 return NULL;
18361 }
18362
18363
18364 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18365 PyObject *obj;
18366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18367 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
18368 return SWIG_Py_Void();
18369 }
18370
18371 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18372 PyObject *resultobj = 0;
18373 wxEvtHandler *result = 0 ;
18374
18375 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
18376 {
18377 PyThreadState* __tstate = wxPyBeginAllowThreads();
18378 result = (wxEvtHandler *)new wxEvtHandler();
18379 wxPyEndAllowThreads(__tstate);
18380 if (PyErr_Occurred()) SWIG_fail;
18381 }
18382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
18383 return resultobj;
18384 fail:
18385 return NULL;
18386 }
18387
18388
18389 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18390 PyObject *resultobj = 0;
18391 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18392 wxEvtHandler *result = 0 ;
18393 void *argp1 = 0 ;
18394 int res1 = 0 ;
18395 PyObject *swig_obj[1] ;
18396
18397 if (!args) SWIG_fail;
18398 swig_obj[0] = args;
18399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18400 if (!SWIG_IsOK(res1)) {
18401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18402 }
18403 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18404 {
18405 PyThreadState* __tstate = wxPyBeginAllowThreads();
18406 result = (wxEvtHandler *)(arg1)->GetNextHandler();
18407 wxPyEndAllowThreads(__tstate);
18408 if (PyErr_Occurred()) SWIG_fail;
18409 }
18410 {
18411 resultobj = wxPyMake_wxObject(result, 0);
18412 }
18413 return resultobj;
18414 fail:
18415 return NULL;
18416 }
18417
18418
18419 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18420 PyObject *resultobj = 0;
18421 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18422 wxEvtHandler *result = 0 ;
18423 void *argp1 = 0 ;
18424 int res1 = 0 ;
18425 PyObject *swig_obj[1] ;
18426
18427 if (!args) SWIG_fail;
18428 swig_obj[0] = args;
18429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18430 if (!SWIG_IsOK(res1)) {
18431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18432 }
18433 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18434 {
18435 PyThreadState* __tstate = wxPyBeginAllowThreads();
18436 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
18437 wxPyEndAllowThreads(__tstate);
18438 if (PyErr_Occurred()) SWIG_fail;
18439 }
18440 {
18441 resultobj = wxPyMake_wxObject(result, 0);
18442 }
18443 return resultobj;
18444 fail:
18445 return NULL;
18446 }
18447
18448
18449 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18450 PyObject *resultobj = 0;
18451 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18452 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18453 void *argp1 = 0 ;
18454 int res1 = 0 ;
18455 void *argp2 = 0 ;
18456 int res2 = 0 ;
18457 PyObject * obj0 = 0 ;
18458 PyObject * obj1 = 0 ;
18459 char * kwnames[] = {
18460 (char *) "self",(char *) "handler", NULL
18461 };
18462
18463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18465 if (!SWIG_IsOK(res1)) {
18466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18467 }
18468 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18469 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18470 if (!SWIG_IsOK(res2)) {
18471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18472 }
18473 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18474 {
18475 PyThreadState* __tstate = wxPyBeginAllowThreads();
18476 (arg1)->SetNextHandler(arg2);
18477 wxPyEndAllowThreads(__tstate);
18478 if (PyErr_Occurred()) SWIG_fail;
18479 }
18480 resultobj = SWIG_Py_Void();
18481 return resultobj;
18482 fail:
18483 return NULL;
18484 }
18485
18486
18487 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18488 PyObject *resultobj = 0;
18489 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18490 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18491 void *argp1 = 0 ;
18492 int res1 = 0 ;
18493 void *argp2 = 0 ;
18494 int res2 = 0 ;
18495 PyObject * obj0 = 0 ;
18496 PyObject * obj1 = 0 ;
18497 char * kwnames[] = {
18498 (char *) "self",(char *) "handler", NULL
18499 };
18500
18501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18503 if (!SWIG_IsOK(res1)) {
18504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18505 }
18506 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18507 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18508 if (!SWIG_IsOK(res2)) {
18509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18510 }
18511 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18512 {
18513 PyThreadState* __tstate = wxPyBeginAllowThreads();
18514 (arg1)->SetPreviousHandler(arg2);
18515 wxPyEndAllowThreads(__tstate);
18516 if (PyErr_Occurred()) SWIG_fail;
18517 }
18518 resultobj = SWIG_Py_Void();
18519 return resultobj;
18520 fail:
18521 return NULL;
18522 }
18523
18524
18525 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18526 PyObject *resultobj = 0;
18527 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18528 bool result;
18529 void *argp1 = 0 ;
18530 int res1 = 0 ;
18531 PyObject *swig_obj[1] ;
18532
18533 if (!args) SWIG_fail;
18534 swig_obj[0] = args;
18535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18536 if (!SWIG_IsOK(res1)) {
18537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18538 }
18539 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18540 {
18541 PyThreadState* __tstate = wxPyBeginAllowThreads();
18542 result = (bool)(arg1)->GetEvtHandlerEnabled();
18543 wxPyEndAllowThreads(__tstate);
18544 if (PyErr_Occurred()) SWIG_fail;
18545 }
18546 {
18547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18548 }
18549 return resultobj;
18550 fail:
18551 return NULL;
18552 }
18553
18554
18555 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18556 PyObject *resultobj = 0;
18557 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18558 bool arg2 ;
18559 void *argp1 = 0 ;
18560 int res1 = 0 ;
18561 bool val2 ;
18562 int ecode2 = 0 ;
18563 PyObject * obj0 = 0 ;
18564 PyObject * obj1 = 0 ;
18565 char * kwnames[] = {
18566 (char *) "self",(char *) "enabled", NULL
18567 };
18568
18569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18571 if (!SWIG_IsOK(res1)) {
18572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18573 }
18574 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18575 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18576 if (!SWIG_IsOK(ecode2)) {
18577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18578 }
18579 arg2 = static_cast< bool >(val2);
18580 {
18581 PyThreadState* __tstate = wxPyBeginAllowThreads();
18582 (arg1)->SetEvtHandlerEnabled(arg2);
18583 wxPyEndAllowThreads(__tstate);
18584 if (PyErr_Occurred()) SWIG_fail;
18585 }
18586 resultobj = SWIG_Py_Void();
18587 return resultobj;
18588 fail:
18589 return NULL;
18590 }
18591
18592
18593 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18594 PyObject *resultobj = 0;
18595 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18596 wxEvent *arg2 = 0 ;
18597 bool result;
18598 void *argp1 = 0 ;
18599 int res1 = 0 ;
18600 void *argp2 = 0 ;
18601 int res2 = 0 ;
18602 PyObject * obj0 = 0 ;
18603 PyObject * obj1 = 0 ;
18604 char * kwnames[] = {
18605 (char *) "self",(char *) "event", NULL
18606 };
18607
18608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18610 if (!SWIG_IsOK(res1)) {
18611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18612 }
18613 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18614 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18615 if (!SWIG_IsOK(res2)) {
18616 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18617 }
18618 if (!argp2) {
18619 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18620 }
18621 arg2 = reinterpret_cast< wxEvent * >(argp2);
18622 {
18623 PyThreadState* __tstate = wxPyBeginAllowThreads();
18624 result = (bool)(arg1)->ProcessEvent(*arg2);
18625 wxPyEndAllowThreads(__tstate);
18626 if (PyErr_Occurred()) SWIG_fail;
18627 }
18628 {
18629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18630 }
18631 return resultobj;
18632 fail:
18633 return NULL;
18634 }
18635
18636
18637 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18638 PyObject *resultobj = 0;
18639 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18640 wxEvent *arg2 = 0 ;
18641 void *argp1 = 0 ;
18642 int res1 = 0 ;
18643 void *argp2 = 0 ;
18644 int res2 = 0 ;
18645 PyObject * obj0 = 0 ;
18646 PyObject * obj1 = 0 ;
18647 char * kwnames[] = {
18648 (char *) "self",(char *) "event", NULL
18649 };
18650
18651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18653 if (!SWIG_IsOK(res1)) {
18654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18655 }
18656 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18657 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18658 if (!SWIG_IsOK(res2)) {
18659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18660 }
18661 if (!argp2) {
18662 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18663 }
18664 arg2 = reinterpret_cast< wxEvent * >(argp2);
18665 {
18666 PyThreadState* __tstate = wxPyBeginAllowThreads();
18667 (arg1)->AddPendingEvent(*arg2);
18668 wxPyEndAllowThreads(__tstate);
18669 if (PyErr_Occurred()) SWIG_fail;
18670 }
18671 resultobj = SWIG_Py_Void();
18672 return resultobj;
18673 fail:
18674 return NULL;
18675 }
18676
18677
18678 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18679 PyObject *resultobj = 0;
18680 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18681 void *argp1 = 0 ;
18682 int res1 = 0 ;
18683 PyObject *swig_obj[1] ;
18684
18685 if (!args) SWIG_fail;
18686 swig_obj[0] = args;
18687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18688 if (!SWIG_IsOK(res1)) {
18689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18690 }
18691 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18692 {
18693 PyThreadState* __tstate = wxPyBeginAllowThreads();
18694 (arg1)->ProcessPendingEvents();
18695 wxPyEndAllowThreads(__tstate);
18696 if (PyErr_Occurred()) SWIG_fail;
18697 }
18698 resultobj = SWIG_Py_Void();
18699 return resultobj;
18700 fail:
18701 return NULL;
18702 }
18703
18704
18705 SWIGINTERN PyObject *_wrap_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18706 PyObject *resultobj = 0;
18707 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18708 bool arg2 = (bool) true ;
18709 void *argp1 = 0 ;
18710 int res1 = 0 ;
18711 bool val2 ;
18712 int ecode2 = 0 ;
18713 PyObject * obj0 = 0 ;
18714 PyObject * obj1 = 0 ;
18715 char * kwnames[] = {
18716 (char *) "self",(char *) "allow", NULL
18717 };
18718
18719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
18720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18721 if (!SWIG_IsOK(res1)) {
18722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18723 }
18724 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18725 if (obj1) {
18726 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18727 if (!SWIG_IsOK(ecode2)) {
18728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
18729 }
18730 arg2 = static_cast< bool >(val2);
18731 }
18732 {
18733 PyThreadState* __tstate = wxPyBeginAllowThreads();
18734 (arg1)->AllowReentrance(arg2);
18735 wxPyEndAllowThreads(__tstate);
18736 if (PyErr_Occurred()) SWIG_fail;
18737 }
18738 resultobj = SWIG_Py_Void();
18739 return resultobj;
18740 fail:
18741 return NULL;
18742 }
18743
18744
18745 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18746 PyObject *resultobj = 0;
18747 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18748 bool result;
18749 void *argp1 = 0 ;
18750 int res1 = 0 ;
18751 PyObject *swig_obj[1] ;
18752
18753 if (!args) SWIG_fail;
18754 swig_obj[0] = args;
18755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18756 if (!SWIG_IsOK(res1)) {
18757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18758 }
18759 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18760 {
18761 PyThreadState* __tstate = wxPyBeginAllowThreads();
18762 result = (bool)(arg1)->IsReentranceAllowed();
18763 wxPyEndAllowThreads(__tstate);
18764 if (PyErr_Occurred()) SWIG_fail;
18765 }
18766 {
18767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18768 }
18769 return resultobj;
18770 fail:
18771 return NULL;
18772 }
18773
18774
18775 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18776 PyObject *resultobj = 0;
18777 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18778 bool result;
18779 void *argp1 = 0 ;
18780 int res1 = 0 ;
18781 PyObject *swig_obj[1] ;
18782
18783 if (!args) SWIG_fail;
18784 swig_obj[0] = args;
18785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18786 if (!SWIG_IsOK(res1)) {
18787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18788 }
18789 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18790 {
18791 PyThreadState* __tstate = wxPyBeginAllowThreads();
18792 result = (bool)(arg1)->IsEventHandlingInProgress();
18793 wxPyEndAllowThreads(__tstate);
18794 if (PyErr_Occurred()) SWIG_fail;
18795 }
18796 {
18797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18798 }
18799 return resultobj;
18800 fail:
18801 return NULL;
18802 }
18803
18804
18805 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18806 PyObject *resultobj = 0;
18807 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18808 int arg2 ;
18809 int arg3 ;
18810 int arg4 ;
18811 PyObject *arg5 = (PyObject *) 0 ;
18812 void *argp1 = 0 ;
18813 int res1 = 0 ;
18814 int val2 ;
18815 int ecode2 = 0 ;
18816 int val3 ;
18817 int ecode3 = 0 ;
18818 int val4 ;
18819 int ecode4 = 0 ;
18820 PyObject * obj0 = 0 ;
18821 PyObject * obj1 = 0 ;
18822 PyObject * obj2 = 0 ;
18823 PyObject * obj3 = 0 ;
18824 PyObject * obj4 = 0 ;
18825 char * kwnames[] = {
18826 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18827 };
18828
18829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18831 if (!SWIG_IsOK(res1)) {
18832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18833 }
18834 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18835 ecode2 = SWIG_AsVal_int(obj1, &val2);
18836 if (!SWIG_IsOK(ecode2)) {
18837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18838 }
18839 arg2 = static_cast< int >(val2);
18840 ecode3 = SWIG_AsVal_int(obj2, &val3);
18841 if (!SWIG_IsOK(ecode3)) {
18842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18843 }
18844 arg3 = static_cast< int >(val3);
18845 ecode4 = SWIG_AsVal_int(obj3, &val4);
18846 if (!SWIG_IsOK(ecode4)) {
18847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18848 }
18849 arg4 = static_cast< int >(val4);
18850 arg5 = obj4;
18851 {
18852 PyThreadState* __tstate = wxPyBeginAllowThreads();
18853 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18854 wxPyEndAllowThreads(__tstate);
18855 if (PyErr_Occurred()) SWIG_fail;
18856 }
18857 resultobj = SWIG_Py_Void();
18858 return resultobj;
18859 fail:
18860 return NULL;
18861 }
18862
18863
18864 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18865 PyObject *resultobj = 0;
18866 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18867 int arg2 ;
18868 int arg3 = (int) -1 ;
18869 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18870 bool result;
18871 void *argp1 = 0 ;
18872 int res1 = 0 ;
18873 int val2 ;
18874 int ecode2 = 0 ;
18875 int val3 ;
18876 int ecode3 = 0 ;
18877 int val4 ;
18878 int ecode4 = 0 ;
18879 PyObject * obj0 = 0 ;
18880 PyObject * obj1 = 0 ;
18881 PyObject * obj2 = 0 ;
18882 PyObject * obj3 = 0 ;
18883 char * kwnames[] = {
18884 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18885 };
18886
18887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18889 if (!SWIG_IsOK(res1)) {
18890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18891 }
18892 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18893 ecode2 = SWIG_AsVal_int(obj1, &val2);
18894 if (!SWIG_IsOK(ecode2)) {
18895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18896 }
18897 arg2 = static_cast< int >(val2);
18898 if (obj2) {
18899 ecode3 = SWIG_AsVal_int(obj2, &val3);
18900 if (!SWIG_IsOK(ecode3)) {
18901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18902 }
18903 arg3 = static_cast< int >(val3);
18904 }
18905 if (obj3) {
18906 ecode4 = SWIG_AsVal_int(obj3, &val4);
18907 if (!SWIG_IsOK(ecode4)) {
18908 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18909 }
18910 arg4 = static_cast< wxEventType >(val4);
18911 }
18912 {
18913 PyThreadState* __tstate = wxPyBeginAllowThreads();
18914 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18915 wxPyEndAllowThreads(__tstate);
18916 if (PyErr_Occurred()) SWIG_fail;
18917 }
18918 {
18919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18920 }
18921 return resultobj;
18922 fail:
18923 return NULL;
18924 }
18925
18926
18927 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18928 PyObject *resultobj = 0;
18929 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18930 PyObject *arg2 = (PyObject *) 0 ;
18931 bool arg3 = (bool) true ;
18932 void *argp1 = 0 ;
18933 int res1 = 0 ;
18934 bool val3 ;
18935 int ecode3 = 0 ;
18936 PyObject * obj0 = 0 ;
18937 PyObject * obj1 = 0 ;
18938 PyObject * obj2 = 0 ;
18939 char * kwnames[] = {
18940 (char *) "self",(char *) "_self",(char *) "incref", NULL
18941 };
18942
18943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18945 if (!SWIG_IsOK(res1)) {
18946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18947 }
18948 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18949 arg2 = obj1;
18950 if (obj2) {
18951 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18952 if (!SWIG_IsOK(ecode3)) {
18953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18954 }
18955 arg3 = static_cast< bool >(val3);
18956 }
18957 {
18958 PyThreadState* __tstate = wxPyBeginAllowThreads();
18959 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18960 wxPyEndAllowThreads(__tstate);
18961 if (PyErr_Occurred()) SWIG_fail;
18962 }
18963 resultobj = SWIG_Py_Void();
18964 return resultobj;
18965 fail:
18966 return NULL;
18967 }
18968
18969
18970 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18971 PyObject *obj;
18972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18973 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18974 return SWIG_Py_Void();
18975 }
18976
18977 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18978 return SWIG_Python_InitShadowInstance(args);
18979 }
18980
18981 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18982 PyObject *resultobj = 0;
18983 wxEventType result;
18984
18985 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18986 {
18987 PyThreadState* __tstate = wxPyBeginAllowThreads();
18988 result = (wxEventType)wxNewEventType();
18989 wxPyEndAllowThreads(__tstate);
18990 if (PyErr_Occurred()) SWIG_fail;
18991 }
18992 resultobj = SWIG_From_int(static_cast< int >(result));
18993 return resultobj;
18994 fail:
18995 return NULL;
18996 }
18997
18998
18999 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19000 PyObject *resultobj = 0;
19001 wxEvent *arg1 = (wxEvent *) 0 ;
19002 void *argp1 = 0 ;
19003 int res1 = 0 ;
19004 PyObject *swig_obj[1] ;
19005
19006 if (!args) SWIG_fail;
19007 swig_obj[0] = args;
19008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
19009 if (!SWIG_IsOK(res1)) {
19010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
19011 }
19012 arg1 = reinterpret_cast< wxEvent * >(argp1);
19013 {
19014 PyThreadState* __tstate = wxPyBeginAllowThreads();
19015 delete arg1;
19016
19017 wxPyEndAllowThreads(__tstate);
19018 if (PyErr_Occurred()) SWIG_fail;
19019 }
19020 resultobj = SWIG_Py_Void();
19021 return resultobj;
19022 fail:
19023 return NULL;
19024 }
19025
19026
19027 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19028 PyObject *resultobj = 0;
19029 wxEvent *arg1 = (wxEvent *) 0 ;
19030 wxEventType arg2 ;
19031 void *argp1 = 0 ;
19032 int res1 = 0 ;
19033 int val2 ;
19034 int ecode2 = 0 ;
19035 PyObject * obj0 = 0 ;
19036 PyObject * obj1 = 0 ;
19037 char * kwnames[] = {
19038 (char *) "self",(char *) "typ", NULL
19039 };
19040
19041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
19042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19043 if (!SWIG_IsOK(res1)) {
19044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
19045 }
19046 arg1 = reinterpret_cast< wxEvent * >(argp1);
19047 ecode2 = SWIG_AsVal_int(obj1, &val2);
19048 if (!SWIG_IsOK(ecode2)) {
19049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
19050 }
19051 arg2 = static_cast< wxEventType >(val2);
19052 {
19053 PyThreadState* __tstate = wxPyBeginAllowThreads();
19054 (arg1)->SetEventType(arg2);
19055 wxPyEndAllowThreads(__tstate);
19056 if (PyErr_Occurred()) SWIG_fail;
19057 }
19058 resultobj = SWIG_Py_Void();
19059 return resultobj;
19060 fail:
19061 return NULL;
19062 }
19063
19064
19065 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19066 PyObject *resultobj = 0;
19067 wxEvent *arg1 = (wxEvent *) 0 ;
19068 wxEventType result;
19069 void *argp1 = 0 ;
19070 int res1 = 0 ;
19071 PyObject *swig_obj[1] ;
19072
19073 if (!args) SWIG_fail;
19074 swig_obj[0] = args;
19075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19076 if (!SWIG_IsOK(res1)) {
19077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
19078 }
19079 arg1 = reinterpret_cast< wxEvent * >(argp1);
19080 {
19081 PyThreadState* __tstate = wxPyBeginAllowThreads();
19082 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
19083 wxPyEndAllowThreads(__tstate);
19084 if (PyErr_Occurred()) SWIG_fail;
19085 }
19086 resultobj = SWIG_From_int(static_cast< int >(result));
19087 return resultobj;
19088 fail:
19089 return NULL;
19090 }
19091
19092
19093 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19094 PyObject *resultobj = 0;
19095 wxEvent *arg1 = (wxEvent *) 0 ;
19096 wxObject *result = 0 ;
19097 void *argp1 = 0 ;
19098 int res1 = 0 ;
19099 PyObject *swig_obj[1] ;
19100
19101 if (!args) SWIG_fail;
19102 swig_obj[0] = args;
19103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19104 if (!SWIG_IsOK(res1)) {
19105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
19106 }
19107 arg1 = reinterpret_cast< wxEvent * >(argp1);
19108 {
19109 PyThreadState* __tstate = wxPyBeginAllowThreads();
19110 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
19111 wxPyEndAllowThreads(__tstate);
19112 if (PyErr_Occurred()) SWIG_fail;
19113 }
19114 {
19115 resultobj = wxPyMake_wxObject(result, (bool)0);
19116 }
19117 return resultobj;
19118 fail:
19119 return NULL;
19120 }
19121
19122
19123 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19124 PyObject *resultobj = 0;
19125 wxEvent *arg1 = (wxEvent *) 0 ;
19126 wxObject *arg2 = (wxObject *) 0 ;
19127 void *argp1 = 0 ;
19128 int res1 = 0 ;
19129 void *argp2 = 0 ;
19130 int res2 = 0 ;
19131 PyObject * obj0 = 0 ;
19132 PyObject * obj1 = 0 ;
19133 char * kwnames[] = {
19134 (char *) "self",(char *) "obj", NULL
19135 };
19136
19137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
19138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19139 if (!SWIG_IsOK(res1)) {
19140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
19141 }
19142 arg1 = reinterpret_cast< wxEvent * >(argp1);
19143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
19144 if (!SWIG_IsOK(res2)) {
19145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
19146 }
19147 arg2 = reinterpret_cast< wxObject * >(argp2);
19148 {
19149 PyThreadState* __tstate = wxPyBeginAllowThreads();
19150 (arg1)->SetEventObject(arg2);
19151 wxPyEndAllowThreads(__tstate);
19152 if (PyErr_Occurred()) SWIG_fail;
19153 }
19154 resultobj = SWIG_Py_Void();
19155 return resultobj;
19156 fail:
19157 return NULL;
19158 }
19159
19160
19161 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19162 PyObject *resultobj = 0;
19163 wxEvent *arg1 = (wxEvent *) 0 ;
19164 long result;
19165 void *argp1 = 0 ;
19166 int res1 = 0 ;
19167 PyObject *swig_obj[1] ;
19168
19169 if (!args) SWIG_fail;
19170 swig_obj[0] = args;
19171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19172 if (!SWIG_IsOK(res1)) {
19173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
19174 }
19175 arg1 = reinterpret_cast< wxEvent * >(argp1);
19176 {
19177 PyThreadState* __tstate = wxPyBeginAllowThreads();
19178 result = (long)((wxEvent const *)arg1)->GetTimestamp();
19179 wxPyEndAllowThreads(__tstate);
19180 if (PyErr_Occurred()) SWIG_fail;
19181 }
19182 resultobj = SWIG_From_long(static_cast< long >(result));
19183 return resultobj;
19184 fail:
19185 return NULL;
19186 }
19187
19188
19189 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19190 PyObject *resultobj = 0;
19191 wxEvent *arg1 = (wxEvent *) 0 ;
19192 long arg2 = (long) 0 ;
19193 void *argp1 = 0 ;
19194 int res1 = 0 ;
19195 long val2 ;
19196 int ecode2 = 0 ;
19197 PyObject * obj0 = 0 ;
19198 PyObject * obj1 = 0 ;
19199 char * kwnames[] = {
19200 (char *) "self",(char *) "ts", NULL
19201 };
19202
19203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
19204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19205 if (!SWIG_IsOK(res1)) {
19206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
19207 }
19208 arg1 = reinterpret_cast< wxEvent * >(argp1);
19209 if (obj1) {
19210 ecode2 = SWIG_AsVal_long(obj1, &val2);
19211 if (!SWIG_IsOK(ecode2)) {
19212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
19213 }
19214 arg2 = static_cast< long >(val2);
19215 }
19216 {
19217 PyThreadState* __tstate = wxPyBeginAllowThreads();
19218 (arg1)->SetTimestamp(arg2);
19219 wxPyEndAllowThreads(__tstate);
19220 if (PyErr_Occurred()) SWIG_fail;
19221 }
19222 resultobj = SWIG_Py_Void();
19223 return resultobj;
19224 fail:
19225 return NULL;
19226 }
19227
19228
19229 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19230 PyObject *resultobj = 0;
19231 wxEvent *arg1 = (wxEvent *) 0 ;
19232 int result;
19233 void *argp1 = 0 ;
19234 int res1 = 0 ;
19235 PyObject *swig_obj[1] ;
19236
19237 if (!args) SWIG_fail;
19238 swig_obj[0] = args;
19239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19240 if (!SWIG_IsOK(res1)) {
19241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
19242 }
19243 arg1 = reinterpret_cast< wxEvent * >(argp1);
19244 {
19245 PyThreadState* __tstate = wxPyBeginAllowThreads();
19246 result = (int)((wxEvent const *)arg1)->GetId();
19247 wxPyEndAllowThreads(__tstate);
19248 if (PyErr_Occurred()) SWIG_fail;
19249 }
19250 resultobj = SWIG_From_int(static_cast< int >(result));
19251 return resultobj;
19252 fail:
19253 return NULL;
19254 }
19255
19256
19257 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19258 PyObject *resultobj = 0;
19259 wxEvent *arg1 = (wxEvent *) 0 ;
19260 int arg2 ;
19261 void *argp1 = 0 ;
19262 int res1 = 0 ;
19263 int val2 ;
19264 int ecode2 = 0 ;
19265 PyObject * obj0 = 0 ;
19266 PyObject * obj1 = 0 ;
19267 char * kwnames[] = {
19268 (char *) "self",(char *) "Id", NULL
19269 };
19270
19271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
19272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19273 if (!SWIG_IsOK(res1)) {
19274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
19275 }
19276 arg1 = reinterpret_cast< wxEvent * >(argp1);
19277 ecode2 = SWIG_AsVal_int(obj1, &val2);
19278 if (!SWIG_IsOK(ecode2)) {
19279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
19280 }
19281 arg2 = static_cast< int >(val2);
19282 {
19283 PyThreadState* __tstate = wxPyBeginAllowThreads();
19284 (arg1)->SetId(arg2);
19285 wxPyEndAllowThreads(__tstate);
19286 if (PyErr_Occurred()) SWIG_fail;
19287 }
19288 resultobj = SWIG_Py_Void();
19289 return resultobj;
19290 fail:
19291 return NULL;
19292 }
19293
19294
19295 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19296 PyObject *resultobj = 0;
19297 wxEvent *arg1 = (wxEvent *) 0 ;
19298 bool result;
19299 void *argp1 = 0 ;
19300 int res1 = 0 ;
19301 PyObject *swig_obj[1] ;
19302
19303 if (!args) SWIG_fail;
19304 swig_obj[0] = args;
19305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19306 if (!SWIG_IsOK(res1)) {
19307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
19308 }
19309 arg1 = reinterpret_cast< wxEvent * >(argp1);
19310 {
19311 PyThreadState* __tstate = wxPyBeginAllowThreads();
19312 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
19313 wxPyEndAllowThreads(__tstate);
19314 if (PyErr_Occurred()) SWIG_fail;
19315 }
19316 {
19317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19318 }
19319 return resultobj;
19320 fail:
19321 return NULL;
19322 }
19323
19324
19325 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19326 PyObject *resultobj = 0;
19327 wxEvent *arg1 = (wxEvent *) 0 ;
19328 bool arg2 = (bool) true ;
19329 void *argp1 = 0 ;
19330 int res1 = 0 ;
19331 bool val2 ;
19332 int ecode2 = 0 ;
19333 PyObject * obj0 = 0 ;
19334 PyObject * obj1 = 0 ;
19335 char * kwnames[] = {
19336 (char *) "self",(char *) "skip", NULL
19337 };
19338
19339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
19340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19341 if (!SWIG_IsOK(res1)) {
19342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
19343 }
19344 arg1 = reinterpret_cast< wxEvent * >(argp1);
19345 if (obj1) {
19346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19347 if (!SWIG_IsOK(ecode2)) {
19348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
19349 }
19350 arg2 = static_cast< bool >(val2);
19351 }
19352 {
19353 PyThreadState* __tstate = wxPyBeginAllowThreads();
19354 (arg1)->Skip(arg2);
19355 wxPyEndAllowThreads(__tstate);
19356 if (PyErr_Occurred()) SWIG_fail;
19357 }
19358 resultobj = SWIG_Py_Void();
19359 return resultobj;
19360 fail:
19361 return NULL;
19362 }
19363
19364
19365 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19366 PyObject *resultobj = 0;
19367 wxEvent *arg1 = (wxEvent *) 0 ;
19368 bool result;
19369 void *argp1 = 0 ;
19370 int res1 = 0 ;
19371 PyObject *swig_obj[1] ;
19372
19373 if (!args) SWIG_fail;
19374 swig_obj[0] = args;
19375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19376 if (!SWIG_IsOK(res1)) {
19377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
19378 }
19379 arg1 = reinterpret_cast< wxEvent * >(argp1);
19380 {
19381 PyThreadState* __tstate = wxPyBeginAllowThreads();
19382 result = (bool)((wxEvent const *)arg1)->GetSkipped();
19383 wxPyEndAllowThreads(__tstate);
19384 if (PyErr_Occurred()) SWIG_fail;
19385 }
19386 {
19387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19388 }
19389 return resultobj;
19390 fail:
19391 return NULL;
19392 }
19393
19394
19395 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19396 PyObject *resultobj = 0;
19397 wxEvent *arg1 = (wxEvent *) 0 ;
19398 bool result;
19399 void *argp1 = 0 ;
19400 int res1 = 0 ;
19401 PyObject *swig_obj[1] ;
19402
19403 if (!args) SWIG_fail;
19404 swig_obj[0] = args;
19405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19406 if (!SWIG_IsOK(res1)) {
19407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
19408 }
19409 arg1 = reinterpret_cast< wxEvent * >(argp1);
19410 {
19411 PyThreadState* __tstate = wxPyBeginAllowThreads();
19412 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
19413 wxPyEndAllowThreads(__tstate);
19414 if (PyErr_Occurred()) SWIG_fail;
19415 }
19416 {
19417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19418 }
19419 return resultobj;
19420 fail:
19421 return NULL;
19422 }
19423
19424
19425 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19426 PyObject *resultobj = 0;
19427 wxEvent *arg1 = (wxEvent *) 0 ;
19428 int result;
19429 void *argp1 = 0 ;
19430 int res1 = 0 ;
19431 PyObject *swig_obj[1] ;
19432
19433 if (!args) SWIG_fail;
19434 swig_obj[0] = args;
19435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19436 if (!SWIG_IsOK(res1)) {
19437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19438 }
19439 arg1 = reinterpret_cast< wxEvent * >(argp1);
19440 {
19441 PyThreadState* __tstate = wxPyBeginAllowThreads();
19442 result = (int)(arg1)->StopPropagation();
19443 wxPyEndAllowThreads(__tstate);
19444 if (PyErr_Occurred()) SWIG_fail;
19445 }
19446 resultobj = SWIG_From_int(static_cast< int >(result));
19447 return resultobj;
19448 fail:
19449 return NULL;
19450 }
19451
19452
19453 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19454 PyObject *resultobj = 0;
19455 wxEvent *arg1 = (wxEvent *) 0 ;
19456 int arg2 ;
19457 void *argp1 = 0 ;
19458 int res1 = 0 ;
19459 int val2 ;
19460 int ecode2 = 0 ;
19461 PyObject * obj0 = 0 ;
19462 PyObject * obj1 = 0 ;
19463 char * kwnames[] = {
19464 (char *) "self",(char *) "propagationLevel", NULL
19465 };
19466
19467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
19468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19469 if (!SWIG_IsOK(res1)) {
19470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19471 }
19472 arg1 = reinterpret_cast< wxEvent * >(argp1);
19473 ecode2 = SWIG_AsVal_int(obj1, &val2);
19474 if (!SWIG_IsOK(ecode2)) {
19475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
19476 }
19477 arg2 = static_cast< int >(val2);
19478 {
19479 PyThreadState* __tstate = wxPyBeginAllowThreads();
19480 (arg1)->ResumePropagation(arg2);
19481 wxPyEndAllowThreads(__tstate);
19482 if (PyErr_Occurred()) SWIG_fail;
19483 }
19484 resultobj = SWIG_Py_Void();
19485 return resultobj;
19486 fail:
19487 return NULL;
19488 }
19489
19490
19491 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19492 PyObject *resultobj = 0;
19493 wxEvent *arg1 = (wxEvent *) 0 ;
19494 wxEvent *result = 0 ;
19495 void *argp1 = 0 ;
19496 int res1 = 0 ;
19497 PyObject *swig_obj[1] ;
19498
19499 if (!args) SWIG_fail;
19500 swig_obj[0] = args;
19501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19502 if (!SWIG_IsOK(res1)) {
19503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
19504 }
19505 arg1 = reinterpret_cast< wxEvent * >(argp1);
19506 {
19507 PyThreadState* __tstate = wxPyBeginAllowThreads();
19508 result = (wxEvent *)(arg1)->Clone();
19509 wxPyEndAllowThreads(__tstate);
19510 if (PyErr_Occurred()) SWIG_fail;
19511 }
19512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19513 return resultobj;
19514 fail:
19515 return NULL;
19516 }
19517
19518
19519 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19520 PyObject *obj;
19521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19522 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
19523 return SWIG_Py_Void();
19524 }
19525
19526 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19527 PyObject *resultobj = 0;
19528 wxEvent *arg1 = 0 ;
19529 wxPropagationDisabler *result = 0 ;
19530 void *argp1 = 0 ;
19531 int res1 = 0 ;
19532 PyObject * obj0 = 0 ;
19533 char * kwnames[] = {
19534 (char *) "event", NULL
19535 };
19536
19537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
19538 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19539 if (!SWIG_IsOK(res1)) {
19540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19541 }
19542 if (!argp1) {
19543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19544 }
19545 arg1 = reinterpret_cast< wxEvent * >(argp1);
19546 {
19547 PyThreadState* __tstate = wxPyBeginAllowThreads();
19548 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
19549 wxPyEndAllowThreads(__tstate);
19550 if (PyErr_Occurred()) SWIG_fail;
19551 }
19552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
19553 return resultobj;
19554 fail:
19555 return NULL;
19556 }
19557
19558
19559 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19560 PyObject *resultobj = 0;
19561 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
19562 void *argp1 = 0 ;
19563 int res1 = 0 ;
19564 PyObject *swig_obj[1] ;
19565
19566 if (!args) SWIG_fail;
19567 swig_obj[0] = args;
19568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
19569 if (!SWIG_IsOK(res1)) {
19570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
19571 }
19572 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
19573 {
19574 PyThreadState* __tstate = wxPyBeginAllowThreads();
19575 delete arg1;
19576
19577 wxPyEndAllowThreads(__tstate);
19578 if (PyErr_Occurred()) SWIG_fail;
19579 }
19580 resultobj = SWIG_Py_Void();
19581 return resultobj;
19582 fail:
19583 return NULL;
19584 }
19585
19586
19587 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19588 PyObject *obj;
19589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19590 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19591 return SWIG_Py_Void();
19592 }
19593
19594 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19595 return SWIG_Python_InitShadowInstance(args);
19596 }
19597
19598 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19599 PyObject *resultobj = 0;
19600 wxEvent *arg1 = 0 ;
19601 wxPropagateOnce *result = 0 ;
19602 void *argp1 = 0 ;
19603 int res1 = 0 ;
19604 PyObject * obj0 = 0 ;
19605 char * kwnames[] = {
19606 (char *) "event", NULL
19607 };
19608
19609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19610 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19611 if (!SWIG_IsOK(res1)) {
19612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19613 }
19614 if (!argp1) {
19615 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19616 }
19617 arg1 = reinterpret_cast< wxEvent * >(argp1);
19618 {
19619 PyThreadState* __tstate = wxPyBeginAllowThreads();
19620 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19621 wxPyEndAllowThreads(__tstate);
19622 if (PyErr_Occurred()) SWIG_fail;
19623 }
19624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19625 return resultobj;
19626 fail:
19627 return NULL;
19628 }
19629
19630
19631 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19632 PyObject *resultobj = 0;
19633 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19634 void *argp1 = 0 ;
19635 int res1 = 0 ;
19636 PyObject *swig_obj[1] ;
19637
19638 if (!args) SWIG_fail;
19639 swig_obj[0] = args;
19640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19641 if (!SWIG_IsOK(res1)) {
19642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19643 }
19644 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19645 {
19646 PyThreadState* __tstate = wxPyBeginAllowThreads();
19647 delete arg1;
19648
19649 wxPyEndAllowThreads(__tstate);
19650 if (PyErr_Occurred()) SWIG_fail;
19651 }
19652 resultobj = SWIG_Py_Void();
19653 return resultobj;
19654 fail:
19655 return NULL;
19656 }
19657
19658
19659 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19660 PyObject *obj;
19661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19662 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19663 return SWIG_Py_Void();
19664 }
19665
19666 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19667 return SWIG_Python_InitShadowInstance(args);
19668 }
19669
19670 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19671 PyObject *resultobj = 0;
19672 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19673 int arg2 = (int) 0 ;
19674 wxCommandEvent *result = 0 ;
19675 int val1 ;
19676 int ecode1 = 0 ;
19677 int val2 ;
19678 int ecode2 = 0 ;
19679 PyObject * obj0 = 0 ;
19680 PyObject * obj1 = 0 ;
19681 char * kwnames[] = {
19682 (char *) "commandType",(char *) "winid", NULL
19683 };
19684
19685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19686 if (obj0) {
19687 ecode1 = SWIG_AsVal_int(obj0, &val1);
19688 if (!SWIG_IsOK(ecode1)) {
19689 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19690 }
19691 arg1 = static_cast< wxEventType >(val1);
19692 }
19693 if (obj1) {
19694 ecode2 = SWIG_AsVal_int(obj1, &val2);
19695 if (!SWIG_IsOK(ecode2)) {
19696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19697 }
19698 arg2 = static_cast< int >(val2);
19699 }
19700 {
19701 PyThreadState* __tstate = wxPyBeginAllowThreads();
19702 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19703 wxPyEndAllowThreads(__tstate);
19704 if (PyErr_Occurred()) SWIG_fail;
19705 }
19706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19707 return resultobj;
19708 fail:
19709 return NULL;
19710 }
19711
19712
19713 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19714 PyObject *resultobj = 0;
19715 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19716 int result;
19717 void *argp1 = 0 ;
19718 int res1 = 0 ;
19719 PyObject *swig_obj[1] ;
19720
19721 if (!args) SWIG_fail;
19722 swig_obj[0] = args;
19723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19724 if (!SWIG_IsOK(res1)) {
19725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19726 }
19727 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19728 {
19729 PyThreadState* __tstate = wxPyBeginAllowThreads();
19730 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19731 wxPyEndAllowThreads(__tstate);
19732 if (PyErr_Occurred()) SWIG_fail;
19733 }
19734 resultobj = SWIG_From_int(static_cast< int >(result));
19735 return resultobj;
19736 fail:
19737 return NULL;
19738 }
19739
19740
19741 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19742 PyObject *resultobj = 0;
19743 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19744 wxString *arg2 = 0 ;
19745 void *argp1 = 0 ;
19746 int res1 = 0 ;
19747 bool temp2 = false ;
19748 PyObject * obj0 = 0 ;
19749 PyObject * obj1 = 0 ;
19750 char * kwnames[] = {
19751 (char *) "self",(char *) "s", NULL
19752 };
19753
19754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19756 if (!SWIG_IsOK(res1)) {
19757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19758 }
19759 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19760 {
19761 arg2 = wxString_in_helper(obj1);
19762 if (arg2 == NULL) SWIG_fail;
19763 temp2 = true;
19764 }
19765 {
19766 PyThreadState* __tstate = wxPyBeginAllowThreads();
19767 (arg1)->SetString((wxString const &)*arg2);
19768 wxPyEndAllowThreads(__tstate);
19769 if (PyErr_Occurred()) SWIG_fail;
19770 }
19771 resultobj = SWIG_Py_Void();
19772 {
19773 if (temp2)
19774 delete arg2;
19775 }
19776 return resultobj;
19777 fail:
19778 {
19779 if (temp2)
19780 delete arg2;
19781 }
19782 return NULL;
19783 }
19784
19785
19786 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19787 PyObject *resultobj = 0;
19788 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19789 wxString result;
19790 void *argp1 = 0 ;
19791 int res1 = 0 ;
19792 PyObject *swig_obj[1] ;
19793
19794 if (!args) SWIG_fail;
19795 swig_obj[0] = args;
19796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19797 if (!SWIG_IsOK(res1)) {
19798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19799 }
19800 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19801 {
19802 PyThreadState* __tstate = wxPyBeginAllowThreads();
19803 result = ((wxCommandEvent const *)arg1)->GetString();
19804 wxPyEndAllowThreads(__tstate);
19805 if (PyErr_Occurred()) SWIG_fail;
19806 }
19807 {
19808 #if wxUSE_UNICODE
19809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19810 #else
19811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19812 #endif
19813 }
19814 return resultobj;
19815 fail:
19816 return NULL;
19817 }
19818
19819
19820 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19821 PyObject *resultobj = 0;
19822 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19823 bool result;
19824 void *argp1 = 0 ;
19825 int res1 = 0 ;
19826 PyObject *swig_obj[1] ;
19827
19828 if (!args) SWIG_fail;
19829 swig_obj[0] = args;
19830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19831 if (!SWIG_IsOK(res1)) {
19832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19833 }
19834 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19835 {
19836 PyThreadState* __tstate = wxPyBeginAllowThreads();
19837 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19838 wxPyEndAllowThreads(__tstate);
19839 if (PyErr_Occurred()) SWIG_fail;
19840 }
19841 {
19842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19843 }
19844 return resultobj;
19845 fail:
19846 return NULL;
19847 }
19848
19849
19850 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19851 PyObject *resultobj = 0;
19852 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19853 bool result;
19854 void *argp1 = 0 ;
19855 int res1 = 0 ;
19856 PyObject *swig_obj[1] ;
19857
19858 if (!args) SWIG_fail;
19859 swig_obj[0] = args;
19860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19861 if (!SWIG_IsOK(res1)) {
19862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19863 }
19864 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19865 {
19866 PyThreadState* __tstate = wxPyBeginAllowThreads();
19867 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19868 wxPyEndAllowThreads(__tstate);
19869 if (PyErr_Occurred()) SWIG_fail;
19870 }
19871 {
19872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19873 }
19874 return resultobj;
19875 fail:
19876 return NULL;
19877 }
19878
19879
19880 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19881 PyObject *resultobj = 0;
19882 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19883 long arg2 ;
19884 void *argp1 = 0 ;
19885 int res1 = 0 ;
19886 long val2 ;
19887 int ecode2 = 0 ;
19888 PyObject * obj0 = 0 ;
19889 PyObject * obj1 = 0 ;
19890 char * kwnames[] = {
19891 (char *) "self",(char *) "extraLong", NULL
19892 };
19893
19894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19896 if (!SWIG_IsOK(res1)) {
19897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19898 }
19899 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19900 ecode2 = SWIG_AsVal_long(obj1, &val2);
19901 if (!SWIG_IsOK(ecode2)) {
19902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19903 }
19904 arg2 = static_cast< long >(val2);
19905 {
19906 PyThreadState* __tstate = wxPyBeginAllowThreads();
19907 (arg1)->SetExtraLong(arg2);
19908 wxPyEndAllowThreads(__tstate);
19909 if (PyErr_Occurred()) SWIG_fail;
19910 }
19911 resultobj = SWIG_Py_Void();
19912 return resultobj;
19913 fail:
19914 return NULL;
19915 }
19916
19917
19918 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19919 PyObject *resultobj = 0;
19920 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19921 long result;
19922 void *argp1 = 0 ;
19923 int res1 = 0 ;
19924 PyObject *swig_obj[1] ;
19925
19926 if (!args) SWIG_fail;
19927 swig_obj[0] = args;
19928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19929 if (!SWIG_IsOK(res1)) {
19930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19931 }
19932 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19933 {
19934 PyThreadState* __tstate = wxPyBeginAllowThreads();
19935 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19936 wxPyEndAllowThreads(__tstate);
19937 if (PyErr_Occurred()) SWIG_fail;
19938 }
19939 resultobj = SWIG_From_long(static_cast< long >(result));
19940 return resultobj;
19941 fail:
19942 return NULL;
19943 }
19944
19945
19946 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19947 PyObject *resultobj = 0;
19948 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19949 int arg2 ;
19950 void *argp1 = 0 ;
19951 int res1 = 0 ;
19952 int val2 ;
19953 int ecode2 = 0 ;
19954 PyObject * obj0 = 0 ;
19955 PyObject * obj1 = 0 ;
19956 char * kwnames[] = {
19957 (char *) "self",(char *) "i", NULL
19958 };
19959
19960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19962 if (!SWIG_IsOK(res1)) {
19963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19964 }
19965 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19966 ecode2 = SWIG_AsVal_int(obj1, &val2);
19967 if (!SWIG_IsOK(ecode2)) {
19968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19969 }
19970 arg2 = static_cast< int >(val2);
19971 {
19972 PyThreadState* __tstate = wxPyBeginAllowThreads();
19973 (arg1)->SetInt(arg2);
19974 wxPyEndAllowThreads(__tstate);
19975 if (PyErr_Occurred()) SWIG_fail;
19976 }
19977 resultobj = SWIG_Py_Void();
19978 return resultobj;
19979 fail:
19980 return NULL;
19981 }
19982
19983
19984 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19985 PyObject *resultobj = 0;
19986 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19987 int result;
19988 void *argp1 = 0 ;
19989 int res1 = 0 ;
19990 PyObject *swig_obj[1] ;
19991
19992 if (!args) SWIG_fail;
19993 swig_obj[0] = args;
19994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19995 if (!SWIG_IsOK(res1)) {
19996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19997 }
19998 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19999 {
20000 PyThreadState* __tstate = wxPyBeginAllowThreads();
20001 result = (int)((wxCommandEvent const *)arg1)->GetInt();
20002 wxPyEndAllowThreads(__tstate);
20003 if (PyErr_Occurred()) SWIG_fail;
20004 }
20005 resultobj = SWIG_From_int(static_cast< int >(result));
20006 return resultobj;
20007 fail:
20008 return NULL;
20009 }
20010
20011
20012 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20013 PyObject *resultobj = 0;
20014 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20015 PyObject *result = 0 ;
20016 void *argp1 = 0 ;
20017 int res1 = 0 ;
20018 PyObject *swig_obj[1] ;
20019
20020 if (!args) SWIG_fail;
20021 swig_obj[0] = args;
20022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20023 if (!SWIG_IsOK(res1)) {
20024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20025 }
20026 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20027 {
20028 PyThreadState* __tstate = wxPyBeginAllowThreads();
20029 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
20030 wxPyEndAllowThreads(__tstate);
20031 if (PyErr_Occurred()) SWIG_fail;
20032 }
20033 resultobj = result;
20034 return resultobj;
20035 fail:
20036 return NULL;
20037 }
20038
20039
20040 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20041 PyObject *resultobj = 0;
20042 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20043 PyObject *arg2 = (PyObject *) 0 ;
20044 void *argp1 = 0 ;
20045 int res1 = 0 ;
20046 PyObject * obj0 = 0 ;
20047 PyObject * obj1 = 0 ;
20048 char * kwnames[] = {
20049 (char *) "self",(char *) "clientData", NULL
20050 };
20051
20052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
20053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20054 if (!SWIG_IsOK(res1)) {
20055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20056 }
20057 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20058 arg2 = obj1;
20059 {
20060 PyThreadState* __tstate = wxPyBeginAllowThreads();
20061 wxCommandEvent_SetClientData(arg1,arg2);
20062 wxPyEndAllowThreads(__tstate);
20063 if (PyErr_Occurred()) SWIG_fail;
20064 }
20065 resultobj = SWIG_Py_Void();
20066 return resultobj;
20067 fail:
20068 return NULL;
20069 }
20070
20071
20072 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20073 PyObject *resultobj = 0;
20074 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20075 wxEvent *result = 0 ;
20076 void *argp1 = 0 ;
20077 int res1 = 0 ;
20078 PyObject *swig_obj[1] ;
20079
20080 if (!args) SWIG_fail;
20081 swig_obj[0] = args;
20082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20083 if (!SWIG_IsOK(res1)) {
20084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
20085 }
20086 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20087 {
20088 PyThreadState* __tstate = wxPyBeginAllowThreads();
20089 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
20090 wxPyEndAllowThreads(__tstate);
20091 if (PyErr_Occurred()) SWIG_fail;
20092 }
20093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
20094 return resultobj;
20095 fail:
20096 return NULL;
20097 }
20098
20099
20100 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20101 PyObject *obj;
20102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20103 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
20104 return SWIG_Py_Void();
20105 }
20106
20107 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20108 return SWIG_Python_InitShadowInstance(args);
20109 }
20110
20111 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20112 PyObject *resultobj = 0;
20113 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20114 int arg2 = (int) 0 ;
20115 wxNotifyEvent *result = 0 ;
20116 int val1 ;
20117 int ecode1 = 0 ;
20118 int val2 ;
20119 int ecode2 = 0 ;
20120 PyObject * obj0 = 0 ;
20121 PyObject * obj1 = 0 ;
20122 char * kwnames[] = {
20123 (char *) "commandType",(char *) "winid", NULL
20124 };
20125
20126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20127 if (obj0) {
20128 ecode1 = SWIG_AsVal_int(obj0, &val1);
20129 if (!SWIG_IsOK(ecode1)) {
20130 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20131 }
20132 arg1 = static_cast< wxEventType >(val1);
20133 }
20134 if (obj1) {
20135 ecode2 = SWIG_AsVal_int(obj1, &val2);
20136 if (!SWIG_IsOK(ecode2)) {
20137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
20138 }
20139 arg2 = static_cast< int >(val2);
20140 }
20141 {
20142 PyThreadState* __tstate = wxPyBeginAllowThreads();
20143 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
20144 wxPyEndAllowThreads(__tstate);
20145 if (PyErr_Occurred()) SWIG_fail;
20146 }
20147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
20148 return resultobj;
20149 fail:
20150 return NULL;
20151 }
20152
20153
20154 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20155 PyObject *resultobj = 0;
20156 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
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_wxNotifyEvent, 0 | 0 );
20164 if (!SWIG_IsOK(res1)) {
20165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20166 }
20167 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20168 {
20169 PyThreadState* __tstate = wxPyBeginAllowThreads();
20170 (arg1)->Veto();
20171 wxPyEndAllowThreads(__tstate);
20172 if (PyErr_Occurred()) SWIG_fail;
20173 }
20174 resultobj = SWIG_Py_Void();
20175 return resultobj;
20176 fail:
20177 return NULL;
20178 }
20179
20180
20181 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20182 PyObject *resultobj = 0;
20183 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20184 void *argp1 = 0 ;
20185 int res1 = 0 ;
20186 PyObject *swig_obj[1] ;
20187
20188 if (!args) SWIG_fail;
20189 swig_obj[0] = args;
20190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20191 if (!SWIG_IsOK(res1)) {
20192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20193 }
20194 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20195 {
20196 PyThreadState* __tstate = wxPyBeginAllowThreads();
20197 (arg1)->Allow();
20198 wxPyEndAllowThreads(__tstate);
20199 if (PyErr_Occurred()) SWIG_fail;
20200 }
20201 resultobj = SWIG_Py_Void();
20202 return resultobj;
20203 fail:
20204 return NULL;
20205 }
20206
20207
20208 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20209 PyObject *resultobj = 0;
20210 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20211 bool result;
20212 void *argp1 = 0 ;
20213 int res1 = 0 ;
20214 PyObject *swig_obj[1] ;
20215
20216 if (!args) SWIG_fail;
20217 swig_obj[0] = args;
20218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20219 if (!SWIG_IsOK(res1)) {
20220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20221 }
20222 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20223 {
20224 PyThreadState* __tstate = wxPyBeginAllowThreads();
20225 result = (bool)(arg1)->IsAllowed();
20226 wxPyEndAllowThreads(__tstate);
20227 if (PyErr_Occurred()) SWIG_fail;
20228 }
20229 {
20230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20231 }
20232 return resultobj;
20233 fail:
20234 return NULL;
20235 }
20236
20237
20238 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20239 PyObject *obj;
20240 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20241 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
20242 return SWIG_Py_Void();
20243 }
20244
20245 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20246 return SWIG_Python_InitShadowInstance(args);
20247 }
20248
20249 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20250 PyObject *resultobj = 0;
20251 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20252 int arg2 = (int) 0 ;
20253 int arg3 = (int) 0 ;
20254 int arg4 = (int) 0 ;
20255 wxScrollEvent *result = 0 ;
20256 int val1 ;
20257 int ecode1 = 0 ;
20258 int val2 ;
20259 int ecode2 = 0 ;
20260 int val3 ;
20261 int ecode3 = 0 ;
20262 int val4 ;
20263 int ecode4 = 0 ;
20264 PyObject * obj0 = 0 ;
20265 PyObject * obj1 = 0 ;
20266 PyObject * obj2 = 0 ;
20267 PyObject * obj3 = 0 ;
20268 char * kwnames[] = {
20269 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
20270 };
20271
20272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20273 if (obj0) {
20274 ecode1 = SWIG_AsVal_int(obj0, &val1);
20275 if (!SWIG_IsOK(ecode1)) {
20276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20277 }
20278 arg1 = static_cast< wxEventType >(val1);
20279 }
20280 if (obj1) {
20281 ecode2 = SWIG_AsVal_int(obj1, &val2);
20282 if (!SWIG_IsOK(ecode2)) {
20283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
20284 }
20285 arg2 = static_cast< int >(val2);
20286 }
20287 if (obj2) {
20288 ecode3 = SWIG_AsVal_int(obj2, &val3);
20289 if (!SWIG_IsOK(ecode3)) {
20290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
20291 }
20292 arg3 = static_cast< int >(val3);
20293 }
20294 if (obj3) {
20295 ecode4 = SWIG_AsVal_int(obj3, &val4);
20296 if (!SWIG_IsOK(ecode4)) {
20297 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
20298 }
20299 arg4 = static_cast< int >(val4);
20300 }
20301 {
20302 PyThreadState* __tstate = wxPyBeginAllowThreads();
20303 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
20304 wxPyEndAllowThreads(__tstate);
20305 if (PyErr_Occurred()) SWIG_fail;
20306 }
20307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
20308 return resultobj;
20309 fail:
20310 return NULL;
20311 }
20312
20313
20314 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20315 PyObject *resultobj = 0;
20316 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20317 int result;
20318 void *argp1 = 0 ;
20319 int res1 = 0 ;
20320 PyObject *swig_obj[1] ;
20321
20322 if (!args) SWIG_fail;
20323 swig_obj[0] = args;
20324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20325 if (!SWIG_IsOK(res1)) {
20326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20327 }
20328 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20329 {
20330 PyThreadState* __tstate = wxPyBeginAllowThreads();
20331 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
20332 wxPyEndAllowThreads(__tstate);
20333 if (PyErr_Occurred()) SWIG_fail;
20334 }
20335 resultobj = SWIG_From_int(static_cast< int >(result));
20336 return resultobj;
20337 fail:
20338 return NULL;
20339 }
20340
20341
20342 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20343 PyObject *resultobj = 0;
20344 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20345 int result;
20346 void *argp1 = 0 ;
20347 int res1 = 0 ;
20348 PyObject *swig_obj[1] ;
20349
20350 if (!args) SWIG_fail;
20351 swig_obj[0] = args;
20352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20353 if (!SWIG_IsOK(res1)) {
20354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20355 }
20356 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20357 {
20358 PyThreadState* __tstate = wxPyBeginAllowThreads();
20359 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
20360 wxPyEndAllowThreads(__tstate);
20361 if (PyErr_Occurred()) SWIG_fail;
20362 }
20363 resultobj = SWIG_From_int(static_cast< int >(result));
20364 return resultobj;
20365 fail:
20366 return NULL;
20367 }
20368
20369
20370 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20371 PyObject *resultobj = 0;
20372 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20373 int arg2 ;
20374 void *argp1 = 0 ;
20375 int res1 = 0 ;
20376 int val2 ;
20377 int ecode2 = 0 ;
20378 PyObject * obj0 = 0 ;
20379 PyObject * obj1 = 0 ;
20380 char * kwnames[] = {
20381 (char *) "self",(char *) "orient", NULL
20382 };
20383
20384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20386 if (!SWIG_IsOK(res1)) {
20387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20388 }
20389 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20390 ecode2 = SWIG_AsVal_int(obj1, &val2);
20391 if (!SWIG_IsOK(ecode2)) {
20392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20393 }
20394 arg2 = static_cast< int >(val2);
20395 {
20396 PyThreadState* __tstate = wxPyBeginAllowThreads();
20397 (arg1)->SetOrientation(arg2);
20398 wxPyEndAllowThreads(__tstate);
20399 if (PyErr_Occurred()) SWIG_fail;
20400 }
20401 resultobj = SWIG_Py_Void();
20402 return resultobj;
20403 fail:
20404 return NULL;
20405 }
20406
20407
20408 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20409 PyObject *resultobj = 0;
20410 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20411 int arg2 ;
20412 void *argp1 = 0 ;
20413 int res1 = 0 ;
20414 int val2 ;
20415 int ecode2 = 0 ;
20416 PyObject * obj0 = 0 ;
20417 PyObject * obj1 = 0 ;
20418 char * kwnames[] = {
20419 (char *) "self",(char *) "pos", NULL
20420 };
20421
20422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20424 if (!SWIG_IsOK(res1)) {
20425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20426 }
20427 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20428 ecode2 = SWIG_AsVal_int(obj1, &val2);
20429 if (!SWIG_IsOK(ecode2)) {
20430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20431 }
20432 arg2 = static_cast< int >(val2);
20433 {
20434 PyThreadState* __tstate = wxPyBeginAllowThreads();
20435 (arg1)->SetPosition(arg2);
20436 wxPyEndAllowThreads(__tstate);
20437 if (PyErr_Occurred()) SWIG_fail;
20438 }
20439 resultobj = SWIG_Py_Void();
20440 return resultobj;
20441 fail:
20442 return NULL;
20443 }
20444
20445
20446 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20447 PyObject *obj;
20448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20449 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
20450 return SWIG_Py_Void();
20451 }
20452
20453 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20454 return SWIG_Python_InitShadowInstance(args);
20455 }
20456
20457 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20458 PyObject *resultobj = 0;
20459 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20460 int arg2 = (int) 0 ;
20461 int arg3 = (int) 0 ;
20462 wxScrollWinEvent *result = 0 ;
20463 int val1 ;
20464 int ecode1 = 0 ;
20465 int val2 ;
20466 int ecode2 = 0 ;
20467 int val3 ;
20468 int ecode3 = 0 ;
20469 PyObject * obj0 = 0 ;
20470 PyObject * obj1 = 0 ;
20471 PyObject * obj2 = 0 ;
20472 char * kwnames[] = {
20473 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
20474 };
20475
20476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20477 if (obj0) {
20478 ecode1 = SWIG_AsVal_int(obj0, &val1);
20479 if (!SWIG_IsOK(ecode1)) {
20480 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20481 }
20482 arg1 = static_cast< wxEventType >(val1);
20483 }
20484 if (obj1) {
20485 ecode2 = SWIG_AsVal_int(obj1, &val2);
20486 if (!SWIG_IsOK(ecode2)) {
20487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
20488 }
20489 arg2 = static_cast< int >(val2);
20490 }
20491 if (obj2) {
20492 ecode3 = SWIG_AsVal_int(obj2, &val3);
20493 if (!SWIG_IsOK(ecode3)) {
20494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
20495 }
20496 arg3 = static_cast< int >(val3);
20497 }
20498 {
20499 PyThreadState* __tstate = wxPyBeginAllowThreads();
20500 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
20501 wxPyEndAllowThreads(__tstate);
20502 if (PyErr_Occurred()) SWIG_fail;
20503 }
20504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
20505 return resultobj;
20506 fail:
20507 return NULL;
20508 }
20509
20510
20511 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20512 PyObject *resultobj = 0;
20513 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20514 int result;
20515 void *argp1 = 0 ;
20516 int res1 = 0 ;
20517 PyObject *swig_obj[1] ;
20518
20519 if (!args) SWIG_fail;
20520 swig_obj[0] = args;
20521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20522 if (!SWIG_IsOK(res1)) {
20523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20524 }
20525 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20526 {
20527 PyThreadState* __tstate = wxPyBeginAllowThreads();
20528 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
20529 wxPyEndAllowThreads(__tstate);
20530 if (PyErr_Occurred()) SWIG_fail;
20531 }
20532 resultobj = SWIG_From_int(static_cast< int >(result));
20533 return resultobj;
20534 fail:
20535 return NULL;
20536 }
20537
20538
20539 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20540 PyObject *resultobj = 0;
20541 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20542 int result;
20543 void *argp1 = 0 ;
20544 int res1 = 0 ;
20545 PyObject *swig_obj[1] ;
20546
20547 if (!args) SWIG_fail;
20548 swig_obj[0] = args;
20549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20550 if (!SWIG_IsOK(res1)) {
20551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20552 }
20553 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20554 {
20555 PyThreadState* __tstate = wxPyBeginAllowThreads();
20556 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
20557 wxPyEndAllowThreads(__tstate);
20558 if (PyErr_Occurred()) SWIG_fail;
20559 }
20560 resultobj = SWIG_From_int(static_cast< int >(result));
20561 return resultobj;
20562 fail:
20563 return NULL;
20564 }
20565
20566
20567 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20568 PyObject *resultobj = 0;
20569 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20570 int arg2 ;
20571 void *argp1 = 0 ;
20572 int res1 = 0 ;
20573 int val2 ;
20574 int ecode2 = 0 ;
20575 PyObject * obj0 = 0 ;
20576 PyObject * obj1 = 0 ;
20577 char * kwnames[] = {
20578 (char *) "self",(char *) "orient", NULL
20579 };
20580
20581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20583 if (!SWIG_IsOK(res1)) {
20584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20585 }
20586 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20587 ecode2 = SWIG_AsVal_int(obj1, &val2);
20588 if (!SWIG_IsOK(ecode2)) {
20589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20590 }
20591 arg2 = static_cast< int >(val2);
20592 {
20593 PyThreadState* __tstate = wxPyBeginAllowThreads();
20594 (arg1)->SetOrientation(arg2);
20595 wxPyEndAllowThreads(__tstate);
20596 if (PyErr_Occurred()) SWIG_fail;
20597 }
20598 resultobj = SWIG_Py_Void();
20599 return resultobj;
20600 fail:
20601 return NULL;
20602 }
20603
20604
20605 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20606 PyObject *resultobj = 0;
20607 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20608 int arg2 ;
20609 void *argp1 = 0 ;
20610 int res1 = 0 ;
20611 int val2 ;
20612 int ecode2 = 0 ;
20613 PyObject * obj0 = 0 ;
20614 PyObject * obj1 = 0 ;
20615 char * kwnames[] = {
20616 (char *) "self",(char *) "pos", NULL
20617 };
20618
20619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20621 if (!SWIG_IsOK(res1)) {
20622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20623 }
20624 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20625 ecode2 = SWIG_AsVal_int(obj1, &val2);
20626 if (!SWIG_IsOK(ecode2)) {
20627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20628 }
20629 arg2 = static_cast< int >(val2);
20630 {
20631 PyThreadState* __tstate = wxPyBeginAllowThreads();
20632 (arg1)->SetPosition(arg2);
20633 wxPyEndAllowThreads(__tstate);
20634 if (PyErr_Occurred()) SWIG_fail;
20635 }
20636 resultobj = SWIG_Py_Void();
20637 return resultobj;
20638 fail:
20639 return NULL;
20640 }
20641
20642
20643 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20644 PyObject *obj;
20645 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20646 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20647 return SWIG_Py_Void();
20648 }
20649
20650 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20651 return SWIG_Python_InitShadowInstance(args);
20652 }
20653
20654 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20655 PyObject *resultobj = 0;
20656 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20657 wxMouseEvent *result = 0 ;
20658 int val1 ;
20659 int ecode1 = 0 ;
20660 PyObject * obj0 = 0 ;
20661 char * kwnames[] = {
20662 (char *) "mouseType", NULL
20663 };
20664
20665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20666 if (obj0) {
20667 ecode1 = SWIG_AsVal_int(obj0, &val1);
20668 if (!SWIG_IsOK(ecode1)) {
20669 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20670 }
20671 arg1 = static_cast< wxEventType >(val1);
20672 }
20673 {
20674 PyThreadState* __tstate = wxPyBeginAllowThreads();
20675 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20676 wxPyEndAllowThreads(__tstate);
20677 if (PyErr_Occurred()) SWIG_fail;
20678 }
20679 {
20680 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20681 }
20682 return resultobj;
20683 fail:
20684 return NULL;
20685 }
20686
20687
20688 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20689 PyObject *resultobj = 0;
20690 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20691 bool result;
20692 void *argp1 = 0 ;
20693 int res1 = 0 ;
20694 PyObject *swig_obj[1] ;
20695
20696 if (!args) SWIG_fail;
20697 swig_obj[0] = args;
20698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20699 if (!SWIG_IsOK(res1)) {
20700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20701 }
20702 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20703 {
20704 PyThreadState* __tstate = wxPyBeginAllowThreads();
20705 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20706 wxPyEndAllowThreads(__tstate);
20707 if (PyErr_Occurred()) SWIG_fail;
20708 }
20709 {
20710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20711 }
20712 return resultobj;
20713 fail:
20714 return NULL;
20715 }
20716
20717
20718 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20719 PyObject *resultobj = 0;
20720 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20721 int arg2 = (int) wxMOUSE_BTN_ANY ;
20722 bool result;
20723 void *argp1 = 0 ;
20724 int res1 = 0 ;
20725 int val2 ;
20726 int ecode2 = 0 ;
20727 PyObject * obj0 = 0 ;
20728 PyObject * obj1 = 0 ;
20729 char * kwnames[] = {
20730 (char *) "self",(char *) "but", NULL
20731 };
20732
20733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20735 if (!SWIG_IsOK(res1)) {
20736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20737 }
20738 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20739 if (obj1) {
20740 ecode2 = SWIG_AsVal_int(obj1, &val2);
20741 if (!SWIG_IsOK(ecode2)) {
20742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20743 }
20744 arg2 = static_cast< int >(val2);
20745 }
20746 {
20747 PyThreadState* __tstate = wxPyBeginAllowThreads();
20748 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20749 wxPyEndAllowThreads(__tstate);
20750 if (PyErr_Occurred()) SWIG_fail;
20751 }
20752 {
20753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20754 }
20755 return resultobj;
20756 fail:
20757 return NULL;
20758 }
20759
20760
20761 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20762 PyObject *resultobj = 0;
20763 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20764 int arg2 = (int) wxMOUSE_BTN_ANY ;
20765 bool result;
20766 void *argp1 = 0 ;
20767 int res1 = 0 ;
20768 int val2 ;
20769 int ecode2 = 0 ;
20770 PyObject * obj0 = 0 ;
20771 PyObject * obj1 = 0 ;
20772 char * kwnames[] = {
20773 (char *) "self",(char *) "but", NULL
20774 };
20775
20776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20778 if (!SWIG_IsOK(res1)) {
20779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20780 }
20781 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20782 if (obj1) {
20783 ecode2 = SWIG_AsVal_int(obj1, &val2);
20784 if (!SWIG_IsOK(ecode2)) {
20785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20786 }
20787 arg2 = static_cast< int >(val2);
20788 }
20789 {
20790 PyThreadState* __tstate = wxPyBeginAllowThreads();
20791 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20792 wxPyEndAllowThreads(__tstate);
20793 if (PyErr_Occurred()) SWIG_fail;
20794 }
20795 {
20796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20797 }
20798 return resultobj;
20799 fail:
20800 return NULL;
20801 }
20802
20803
20804 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20805 PyObject *resultobj = 0;
20806 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20807 int arg2 = (int) wxMOUSE_BTN_ANY ;
20808 bool result;
20809 void *argp1 = 0 ;
20810 int res1 = 0 ;
20811 int val2 ;
20812 int ecode2 = 0 ;
20813 PyObject * obj0 = 0 ;
20814 PyObject * obj1 = 0 ;
20815 char * kwnames[] = {
20816 (char *) "self",(char *) "but", NULL
20817 };
20818
20819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20821 if (!SWIG_IsOK(res1)) {
20822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20823 }
20824 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20825 if (obj1) {
20826 ecode2 = SWIG_AsVal_int(obj1, &val2);
20827 if (!SWIG_IsOK(ecode2)) {
20828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20829 }
20830 arg2 = static_cast< int >(val2);
20831 }
20832 {
20833 PyThreadState* __tstate = wxPyBeginAllowThreads();
20834 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20835 wxPyEndAllowThreads(__tstate);
20836 if (PyErr_Occurred()) SWIG_fail;
20837 }
20838 {
20839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20840 }
20841 return resultobj;
20842 fail:
20843 return NULL;
20844 }
20845
20846
20847 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20848 PyObject *resultobj = 0;
20849 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20850 int arg2 ;
20851 bool result;
20852 void *argp1 = 0 ;
20853 int res1 = 0 ;
20854 int val2 ;
20855 int ecode2 = 0 ;
20856 PyObject * obj0 = 0 ;
20857 PyObject * obj1 = 0 ;
20858 char * kwnames[] = {
20859 (char *) "self",(char *) "button", NULL
20860 };
20861
20862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20864 if (!SWIG_IsOK(res1)) {
20865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20866 }
20867 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20868 ecode2 = SWIG_AsVal_int(obj1, &val2);
20869 if (!SWIG_IsOK(ecode2)) {
20870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20871 }
20872 arg2 = static_cast< int >(val2);
20873 {
20874 PyThreadState* __tstate = wxPyBeginAllowThreads();
20875 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20876 wxPyEndAllowThreads(__tstate);
20877 if (PyErr_Occurred()) SWIG_fail;
20878 }
20879 {
20880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20881 }
20882 return resultobj;
20883 fail:
20884 return NULL;
20885 }
20886
20887
20888 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20889 PyObject *resultobj = 0;
20890 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20891 int arg2 ;
20892 bool result;
20893 void *argp1 = 0 ;
20894 int res1 = 0 ;
20895 int val2 ;
20896 int ecode2 = 0 ;
20897 PyObject * obj0 = 0 ;
20898 PyObject * obj1 = 0 ;
20899 char * kwnames[] = {
20900 (char *) "self",(char *) "but", NULL
20901 };
20902
20903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20905 if (!SWIG_IsOK(res1)) {
20906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20907 }
20908 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20909 ecode2 = SWIG_AsVal_int(obj1, &val2);
20910 if (!SWIG_IsOK(ecode2)) {
20911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20912 }
20913 arg2 = static_cast< int >(val2);
20914 {
20915 PyThreadState* __tstate = wxPyBeginAllowThreads();
20916 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20917 wxPyEndAllowThreads(__tstate);
20918 if (PyErr_Occurred()) SWIG_fail;
20919 }
20920 {
20921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20922 }
20923 return resultobj;
20924 fail:
20925 return NULL;
20926 }
20927
20928
20929 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20930 PyObject *resultobj = 0;
20931 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20932 int result;
20933 void *argp1 = 0 ;
20934 int res1 = 0 ;
20935 PyObject *swig_obj[1] ;
20936
20937 if (!args) SWIG_fail;
20938 swig_obj[0] = args;
20939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20940 if (!SWIG_IsOK(res1)) {
20941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20942 }
20943 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20944 {
20945 PyThreadState* __tstate = wxPyBeginAllowThreads();
20946 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20947 wxPyEndAllowThreads(__tstate);
20948 if (PyErr_Occurred()) SWIG_fail;
20949 }
20950 resultobj = SWIG_From_int(static_cast< int >(result));
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20958 PyObject *resultobj = 0;
20959 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20960 bool result;
20961 void *argp1 = 0 ;
20962 int res1 = 0 ;
20963 PyObject *swig_obj[1] ;
20964
20965 if (!args) SWIG_fail;
20966 swig_obj[0] = args;
20967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20968 if (!SWIG_IsOK(res1)) {
20969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20970 }
20971 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20972 {
20973 PyThreadState* __tstate = wxPyBeginAllowThreads();
20974 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20975 wxPyEndAllowThreads(__tstate);
20976 if (PyErr_Occurred()) SWIG_fail;
20977 }
20978 {
20979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20980 }
20981 return resultobj;
20982 fail:
20983 return NULL;
20984 }
20985
20986
20987 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20988 PyObject *resultobj = 0;
20989 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20990 bool result;
20991 void *argp1 = 0 ;
20992 int res1 = 0 ;
20993 PyObject *swig_obj[1] ;
20994
20995 if (!args) SWIG_fail;
20996 swig_obj[0] = args;
20997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20998 if (!SWIG_IsOK(res1)) {
20999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21000 }
21001 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21002 {
21003 PyThreadState* __tstate = wxPyBeginAllowThreads();
21004 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
21005 wxPyEndAllowThreads(__tstate);
21006 if (PyErr_Occurred()) SWIG_fail;
21007 }
21008 {
21009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21010 }
21011 return resultobj;
21012 fail:
21013 return NULL;
21014 }
21015
21016
21017 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21018 PyObject *resultobj = 0;
21019 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21020 bool result;
21021 void *argp1 = 0 ;
21022 int res1 = 0 ;
21023 PyObject *swig_obj[1] ;
21024
21025 if (!args) SWIG_fail;
21026 swig_obj[0] = args;
21027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21028 if (!SWIG_IsOK(res1)) {
21029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21030 }
21031 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21032 {
21033 PyThreadState* __tstate = wxPyBeginAllowThreads();
21034 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
21035 wxPyEndAllowThreads(__tstate);
21036 if (PyErr_Occurred()) SWIG_fail;
21037 }
21038 {
21039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21040 }
21041 return resultobj;
21042 fail:
21043 return NULL;
21044 }
21045
21046
21047 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21048 PyObject *resultobj = 0;
21049 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21050 bool result;
21051 void *argp1 = 0 ;
21052 int res1 = 0 ;
21053 PyObject *swig_obj[1] ;
21054
21055 if (!args) SWIG_fail;
21056 swig_obj[0] = args;
21057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21058 if (!SWIG_IsOK(res1)) {
21059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21060 }
21061 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21062 {
21063 PyThreadState* __tstate = wxPyBeginAllowThreads();
21064 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
21065 wxPyEndAllowThreads(__tstate);
21066 if (PyErr_Occurred()) SWIG_fail;
21067 }
21068 {
21069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21070 }
21071 return resultobj;
21072 fail:
21073 return NULL;
21074 }
21075
21076
21077 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21078 PyObject *resultobj = 0;
21079 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21080 bool result;
21081 void *argp1 = 0 ;
21082 int res1 = 0 ;
21083 PyObject *swig_obj[1] ;
21084
21085 if (!args) SWIG_fail;
21086 swig_obj[0] = args;
21087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21088 if (!SWIG_IsOK(res1)) {
21089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21090 }
21091 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21092 {
21093 PyThreadState* __tstate = wxPyBeginAllowThreads();
21094 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
21095 wxPyEndAllowThreads(__tstate);
21096 if (PyErr_Occurred()) SWIG_fail;
21097 }
21098 {
21099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21100 }
21101 return resultobj;
21102 fail:
21103 return NULL;
21104 }
21105
21106
21107 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21108 PyObject *resultobj = 0;
21109 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21110 bool result;
21111 void *argp1 = 0 ;
21112 int res1 = 0 ;
21113 PyObject *swig_obj[1] ;
21114
21115 if (!args) SWIG_fail;
21116 swig_obj[0] = args;
21117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21118 if (!SWIG_IsOK(res1)) {
21119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21120 }
21121 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21122 {
21123 PyThreadState* __tstate = wxPyBeginAllowThreads();
21124 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
21125 wxPyEndAllowThreads(__tstate);
21126 if (PyErr_Occurred()) SWIG_fail;
21127 }
21128 {
21129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21130 }
21131 return resultobj;
21132 fail:
21133 return NULL;
21134 }
21135
21136
21137 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21138 PyObject *resultobj = 0;
21139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21140 bool result;
21141 void *argp1 = 0 ;
21142 int res1 = 0 ;
21143 PyObject *swig_obj[1] ;
21144
21145 if (!args) SWIG_fail;
21146 swig_obj[0] = args;
21147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21148 if (!SWIG_IsOK(res1)) {
21149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21150 }
21151 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21152 {
21153 PyThreadState* __tstate = wxPyBeginAllowThreads();
21154 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
21155 wxPyEndAllowThreads(__tstate);
21156 if (PyErr_Occurred()) SWIG_fail;
21157 }
21158 {
21159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21160 }
21161 return resultobj;
21162 fail:
21163 return NULL;
21164 }
21165
21166
21167 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21168 PyObject *resultobj = 0;
21169 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21170 bool result;
21171 void *argp1 = 0 ;
21172 int res1 = 0 ;
21173 PyObject *swig_obj[1] ;
21174
21175 if (!args) SWIG_fail;
21176 swig_obj[0] = args;
21177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21178 if (!SWIG_IsOK(res1)) {
21179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21180 }
21181 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21182 {
21183 PyThreadState* __tstate = wxPyBeginAllowThreads();
21184 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
21185 wxPyEndAllowThreads(__tstate);
21186 if (PyErr_Occurred()) SWIG_fail;
21187 }
21188 {
21189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21190 }
21191 return resultobj;
21192 fail:
21193 return NULL;
21194 }
21195
21196
21197 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21198 PyObject *resultobj = 0;
21199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21200 bool result;
21201 void *argp1 = 0 ;
21202 int res1 = 0 ;
21203 PyObject *swig_obj[1] ;
21204
21205 if (!args) SWIG_fail;
21206 swig_obj[0] = args;
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_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21210 }
21211 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21212 {
21213 PyThreadState* __tstate = wxPyBeginAllowThreads();
21214 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
21215 wxPyEndAllowThreads(__tstate);
21216 if (PyErr_Occurred()) SWIG_fail;
21217 }
21218 {
21219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21220 }
21221 return resultobj;
21222 fail:
21223 return NULL;
21224 }
21225
21226
21227 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21228 PyObject *resultobj = 0;
21229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21230 bool result;
21231 void *argp1 = 0 ;
21232 int res1 = 0 ;
21233 PyObject *swig_obj[1] ;
21234
21235 if (!args) SWIG_fail;
21236 swig_obj[0] = args;
21237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21238 if (!SWIG_IsOK(res1)) {
21239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21240 }
21241 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21242 {
21243 PyThreadState* __tstate = wxPyBeginAllowThreads();
21244 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
21245 wxPyEndAllowThreads(__tstate);
21246 if (PyErr_Occurred()) SWIG_fail;
21247 }
21248 {
21249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21250 }
21251 return resultobj;
21252 fail:
21253 return NULL;
21254 }
21255
21256
21257 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21258 PyObject *resultobj = 0;
21259 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21260 bool result;
21261 void *argp1 = 0 ;
21262 int res1 = 0 ;
21263 PyObject *swig_obj[1] ;
21264
21265 if (!args) SWIG_fail;
21266 swig_obj[0] = args;
21267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21268 if (!SWIG_IsOK(res1)) {
21269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21270 }
21271 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21272 {
21273 PyThreadState* __tstate = wxPyBeginAllowThreads();
21274 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
21275 wxPyEndAllowThreads(__tstate);
21276 if (PyErr_Occurred()) SWIG_fail;
21277 }
21278 {
21279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21280 }
21281 return resultobj;
21282 fail:
21283 return NULL;
21284 }
21285
21286
21287 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21288 PyObject *resultobj = 0;
21289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21290 bool result;
21291 void *argp1 = 0 ;
21292 int res1 = 0 ;
21293 PyObject *swig_obj[1] ;
21294
21295 if (!args) SWIG_fail;
21296 swig_obj[0] = args;
21297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21298 if (!SWIG_IsOK(res1)) {
21299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21300 }
21301 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21302 {
21303 PyThreadState* __tstate = wxPyBeginAllowThreads();
21304 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
21305 wxPyEndAllowThreads(__tstate);
21306 if (PyErr_Occurred()) SWIG_fail;
21307 }
21308 {
21309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21310 }
21311 return resultobj;
21312 fail:
21313 return NULL;
21314 }
21315
21316
21317 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21318 PyObject *resultobj = 0;
21319 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21320 bool result;
21321 void *argp1 = 0 ;
21322 int res1 = 0 ;
21323 PyObject *swig_obj[1] ;
21324
21325 if (!args) SWIG_fail;
21326 swig_obj[0] = args;
21327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21328 if (!SWIG_IsOK(res1)) {
21329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21330 }
21331 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21332 {
21333 PyThreadState* __tstate = wxPyBeginAllowThreads();
21334 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
21335 wxPyEndAllowThreads(__tstate);
21336 if (PyErr_Occurred()) SWIG_fail;
21337 }
21338 {
21339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21340 }
21341 return resultobj;
21342 fail:
21343 return NULL;
21344 }
21345
21346
21347 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21348 PyObject *resultobj = 0;
21349 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21350 bool result;
21351 void *argp1 = 0 ;
21352 int res1 = 0 ;
21353 PyObject *swig_obj[1] ;
21354
21355 if (!args) SWIG_fail;
21356 swig_obj[0] = args;
21357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21358 if (!SWIG_IsOK(res1)) {
21359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21360 }
21361 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21362 {
21363 PyThreadState* __tstate = wxPyBeginAllowThreads();
21364 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
21365 wxPyEndAllowThreads(__tstate);
21366 if (PyErr_Occurred()) SWIG_fail;
21367 }
21368 {
21369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21370 }
21371 return resultobj;
21372 fail:
21373 return NULL;
21374 }
21375
21376
21377 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21378 PyObject *resultobj = 0;
21379 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21380 bool result;
21381 void *argp1 = 0 ;
21382 int res1 = 0 ;
21383 PyObject *swig_obj[1] ;
21384
21385 if (!args) SWIG_fail;
21386 swig_obj[0] = args;
21387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21388 if (!SWIG_IsOK(res1)) {
21389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21390 }
21391 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21392 {
21393 PyThreadState* __tstate = wxPyBeginAllowThreads();
21394 result = (bool)(arg1)->LeftIsDown();
21395 wxPyEndAllowThreads(__tstate);
21396 if (PyErr_Occurred()) SWIG_fail;
21397 }
21398 {
21399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21400 }
21401 return resultobj;
21402 fail:
21403 return NULL;
21404 }
21405
21406
21407 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21408 PyObject *resultobj = 0;
21409 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21410 bool result;
21411 void *argp1 = 0 ;
21412 int res1 = 0 ;
21413 PyObject *swig_obj[1] ;
21414
21415 if (!args) SWIG_fail;
21416 swig_obj[0] = args;
21417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21418 if (!SWIG_IsOK(res1)) {
21419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21420 }
21421 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21422 {
21423 PyThreadState* __tstate = wxPyBeginAllowThreads();
21424 result = (bool)(arg1)->MiddleIsDown();
21425 wxPyEndAllowThreads(__tstate);
21426 if (PyErr_Occurred()) SWIG_fail;
21427 }
21428 {
21429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21430 }
21431 return resultobj;
21432 fail:
21433 return NULL;
21434 }
21435
21436
21437 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21438 PyObject *resultobj = 0;
21439 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21440 bool result;
21441 void *argp1 = 0 ;
21442 int res1 = 0 ;
21443 PyObject *swig_obj[1] ;
21444
21445 if (!args) SWIG_fail;
21446 swig_obj[0] = args;
21447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21448 if (!SWIG_IsOK(res1)) {
21449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21450 }
21451 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21452 {
21453 PyThreadState* __tstate = wxPyBeginAllowThreads();
21454 result = (bool)(arg1)->RightIsDown();
21455 wxPyEndAllowThreads(__tstate);
21456 if (PyErr_Occurred()) SWIG_fail;
21457 }
21458 {
21459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21460 }
21461 return resultobj;
21462 fail:
21463 return NULL;
21464 }
21465
21466
21467 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21468 PyObject *resultobj = 0;
21469 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21470 bool result;
21471 void *argp1 = 0 ;
21472 int res1 = 0 ;
21473 PyObject *swig_obj[1] ;
21474
21475 if (!args) SWIG_fail;
21476 swig_obj[0] = args;
21477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21478 if (!SWIG_IsOK(res1)) {
21479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21480 }
21481 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21482 {
21483 PyThreadState* __tstate = wxPyBeginAllowThreads();
21484 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
21485 wxPyEndAllowThreads(__tstate);
21486 if (PyErr_Occurred()) SWIG_fail;
21487 }
21488 {
21489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21490 }
21491 return resultobj;
21492 fail:
21493 return NULL;
21494 }
21495
21496
21497 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21498 PyObject *resultobj = 0;
21499 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21500 bool result;
21501 void *argp1 = 0 ;
21502 int res1 = 0 ;
21503 PyObject *swig_obj[1] ;
21504
21505 if (!args) SWIG_fail;
21506 swig_obj[0] = args;
21507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21508 if (!SWIG_IsOK(res1)) {
21509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21510 }
21511 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21512 {
21513 PyThreadState* __tstate = wxPyBeginAllowThreads();
21514 result = (bool)((wxMouseEvent const *)arg1)->Moving();
21515 wxPyEndAllowThreads(__tstate);
21516 if (PyErr_Occurred()) SWIG_fail;
21517 }
21518 {
21519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21520 }
21521 return resultobj;
21522 fail:
21523 return NULL;
21524 }
21525
21526
21527 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21528 PyObject *resultobj = 0;
21529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21530 bool result;
21531 void *argp1 = 0 ;
21532 int res1 = 0 ;
21533 PyObject *swig_obj[1] ;
21534
21535 if (!args) SWIG_fail;
21536 swig_obj[0] = args;
21537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21538 if (!SWIG_IsOK(res1)) {
21539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21540 }
21541 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21542 {
21543 PyThreadState* __tstate = wxPyBeginAllowThreads();
21544 result = (bool)((wxMouseEvent const *)arg1)->Entering();
21545 wxPyEndAllowThreads(__tstate);
21546 if (PyErr_Occurred()) SWIG_fail;
21547 }
21548 {
21549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21550 }
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21558 PyObject *resultobj = 0;
21559 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21560 bool result;
21561 void *argp1 = 0 ;
21562 int res1 = 0 ;
21563 PyObject *swig_obj[1] ;
21564
21565 if (!args) SWIG_fail;
21566 swig_obj[0] = args;
21567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21568 if (!SWIG_IsOK(res1)) {
21569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21570 }
21571 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21572 {
21573 PyThreadState* __tstate = wxPyBeginAllowThreads();
21574 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
21575 wxPyEndAllowThreads(__tstate);
21576 if (PyErr_Occurred()) SWIG_fail;
21577 }
21578 {
21579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21580 }
21581 return resultobj;
21582 fail:
21583 return NULL;
21584 }
21585
21586
21587 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21588 PyObject *resultobj = 0;
21589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21590 wxPoint result;
21591 void *argp1 = 0 ;
21592 int res1 = 0 ;
21593 PyObject *swig_obj[1] ;
21594
21595 if (!args) SWIG_fail;
21596 swig_obj[0] = args;
21597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21598 if (!SWIG_IsOK(res1)) {
21599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21600 }
21601 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21602 {
21603 PyThreadState* __tstate = wxPyBeginAllowThreads();
21604 result = (arg1)->GetPosition();
21605 wxPyEndAllowThreads(__tstate);
21606 if (PyErr_Occurred()) SWIG_fail;
21607 }
21608 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21609 return resultobj;
21610 fail:
21611 return NULL;
21612 }
21613
21614
21615 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21616 PyObject *resultobj = 0;
21617 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21618 long *arg2 = (long *) 0 ;
21619 long *arg3 = (long *) 0 ;
21620 void *argp1 = 0 ;
21621 int res1 = 0 ;
21622 long temp2 ;
21623 int res2 = SWIG_TMPOBJ ;
21624 long temp3 ;
21625 int res3 = SWIG_TMPOBJ ;
21626 PyObject *swig_obj[1] ;
21627
21628 arg2 = &temp2;
21629 arg3 = &temp3;
21630 if (!args) SWIG_fail;
21631 swig_obj[0] = args;
21632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21633 if (!SWIG_IsOK(res1)) {
21634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21635 }
21636 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21637 {
21638 PyThreadState* __tstate = wxPyBeginAllowThreads();
21639 (arg1)->GetPosition(arg2,arg3);
21640 wxPyEndAllowThreads(__tstate);
21641 if (PyErr_Occurred()) SWIG_fail;
21642 }
21643 resultobj = SWIG_Py_Void();
21644 if (SWIG_IsTmpObj(res2)) {
21645 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21646 } else {
21647 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21648 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21649 }
21650 if (SWIG_IsTmpObj(res3)) {
21651 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21652 } else {
21653 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21654 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21655 }
21656 return resultobj;
21657 fail:
21658 return NULL;
21659 }
21660
21661
21662 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21663 PyObject *resultobj = 0;
21664 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21665 wxDC *arg2 = 0 ;
21666 wxPoint result;
21667 void *argp1 = 0 ;
21668 int res1 = 0 ;
21669 void *argp2 = 0 ;
21670 int res2 = 0 ;
21671 PyObject * obj0 = 0 ;
21672 PyObject * obj1 = 0 ;
21673 char * kwnames[] = {
21674 (char *) "self",(char *) "dc", NULL
21675 };
21676
21677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21679 if (!SWIG_IsOK(res1)) {
21680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21681 }
21682 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21683 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21684 if (!SWIG_IsOK(res2)) {
21685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21686 }
21687 if (!argp2) {
21688 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21689 }
21690 arg2 = reinterpret_cast< wxDC * >(argp2);
21691 {
21692 PyThreadState* __tstate = wxPyBeginAllowThreads();
21693 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21694 wxPyEndAllowThreads(__tstate);
21695 if (PyErr_Occurred()) SWIG_fail;
21696 }
21697 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21698 return resultobj;
21699 fail:
21700 return NULL;
21701 }
21702
21703
21704 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21705 PyObject *resultobj = 0;
21706 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21707 int result;
21708 void *argp1 = 0 ;
21709 int res1 = 0 ;
21710 PyObject *swig_obj[1] ;
21711
21712 if (!args) SWIG_fail;
21713 swig_obj[0] = args;
21714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21715 if (!SWIG_IsOK(res1)) {
21716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21717 }
21718 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21719 {
21720 PyThreadState* __tstate = wxPyBeginAllowThreads();
21721 result = (int)((wxMouseEvent const *)arg1)->GetX();
21722 wxPyEndAllowThreads(__tstate);
21723 if (PyErr_Occurred()) SWIG_fail;
21724 }
21725 resultobj = SWIG_From_int(static_cast< int >(result));
21726 return resultobj;
21727 fail:
21728 return NULL;
21729 }
21730
21731
21732 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21733 PyObject *resultobj = 0;
21734 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21735 int result;
21736 void *argp1 = 0 ;
21737 int res1 = 0 ;
21738 PyObject *swig_obj[1] ;
21739
21740 if (!args) SWIG_fail;
21741 swig_obj[0] = args;
21742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21743 if (!SWIG_IsOK(res1)) {
21744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21745 }
21746 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21747 {
21748 PyThreadState* __tstate = wxPyBeginAllowThreads();
21749 result = (int)((wxMouseEvent const *)arg1)->GetY();
21750 wxPyEndAllowThreads(__tstate);
21751 if (PyErr_Occurred()) SWIG_fail;
21752 }
21753 resultobj = SWIG_From_int(static_cast< int >(result));
21754 return resultobj;
21755 fail:
21756 return NULL;
21757 }
21758
21759
21760 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21761 PyObject *resultobj = 0;
21762 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21763 int result;
21764 void *argp1 = 0 ;
21765 int res1 = 0 ;
21766 PyObject *swig_obj[1] ;
21767
21768 if (!args) SWIG_fail;
21769 swig_obj[0] = args;
21770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21771 if (!SWIG_IsOK(res1)) {
21772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21773 }
21774 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21775 {
21776 PyThreadState* __tstate = wxPyBeginAllowThreads();
21777 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21778 wxPyEndAllowThreads(__tstate);
21779 if (PyErr_Occurred()) SWIG_fail;
21780 }
21781 resultobj = SWIG_From_int(static_cast< int >(result));
21782 return resultobj;
21783 fail:
21784 return NULL;
21785 }
21786
21787
21788 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21789 PyObject *resultobj = 0;
21790 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21791 int result;
21792 void *argp1 = 0 ;
21793 int res1 = 0 ;
21794 PyObject *swig_obj[1] ;
21795
21796 if (!args) SWIG_fail;
21797 swig_obj[0] = args;
21798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21799 if (!SWIG_IsOK(res1)) {
21800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21801 }
21802 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21803 {
21804 PyThreadState* __tstate = wxPyBeginAllowThreads();
21805 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21806 wxPyEndAllowThreads(__tstate);
21807 if (PyErr_Occurred()) SWIG_fail;
21808 }
21809 resultobj = SWIG_From_int(static_cast< int >(result));
21810 return resultobj;
21811 fail:
21812 return NULL;
21813 }
21814
21815
21816 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21817 PyObject *resultobj = 0;
21818 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21819 int result;
21820 void *argp1 = 0 ;
21821 int res1 = 0 ;
21822 PyObject *swig_obj[1] ;
21823
21824 if (!args) SWIG_fail;
21825 swig_obj[0] = args;
21826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21827 if (!SWIG_IsOK(res1)) {
21828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21829 }
21830 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21831 {
21832 PyThreadState* __tstate = wxPyBeginAllowThreads();
21833 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21834 wxPyEndAllowThreads(__tstate);
21835 if (PyErr_Occurred()) SWIG_fail;
21836 }
21837 resultobj = SWIG_From_int(static_cast< int >(result));
21838 return resultobj;
21839 fail:
21840 return NULL;
21841 }
21842
21843
21844 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21845 PyObject *resultobj = 0;
21846 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21847 bool result;
21848 void *argp1 = 0 ;
21849 int res1 = 0 ;
21850 PyObject *swig_obj[1] ;
21851
21852 if (!args) SWIG_fail;
21853 swig_obj[0] = args;
21854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21855 if (!SWIG_IsOK(res1)) {
21856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21857 }
21858 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21859 {
21860 PyThreadState* __tstate = wxPyBeginAllowThreads();
21861 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21862 wxPyEndAllowThreads(__tstate);
21863 if (PyErr_Occurred()) SWIG_fail;
21864 }
21865 {
21866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21867 }
21868 return resultobj;
21869 fail:
21870 return NULL;
21871 }
21872
21873
21874 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21875 PyObject *resultobj = 0;
21876 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21877 int arg2 ;
21878 void *argp1 = 0 ;
21879 int res1 = 0 ;
21880 int val2 ;
21881 int ecode2 = 0 ;
21882 PyObject *swig_obj[2] ;
21883
21884 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21886 if (!SWIG_IsOK(res1)) {
21887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21888 }
21889 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21890 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21891 if (!SWIG_IsOK(ecode2)) {
21892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21893 }
21894 arg2 = static_cast< int >(val2);
21895 if (arg1) (arg1)->m_x = arg2;
21896
21897 resultobj = SWIG_Py_Void();
21898 return resultobj;
21899 fail:
21900 return NULL;
21901 }
21902
21903
21904 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21905 PyObject *resultobj = 0;
21906 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21907 int result;
21908 void *argp1 = 0 ;
21909 int res1 = 0 ;
21910 PyObject *swig_obj[1] ;
21911
21912 if (!args) SWIG_fail;
21913 swig_obj[0] = args;
21914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21915 if (!SWIG_IsOK(res1)) {
21916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21917 }
21918 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21919 result = (int) ((arg1)->m_x);
21920 resultobj = SWIG_From_int(static_cast< int >(result));
21921 return resultobj;
21922 fail:
21923 return NULL;
21924 }
21925
21926
21927 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21928 PyObject *resultobj = 0;
21929 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21930 int arg2 ;
21931 void *argp1 = 0 ;
21932 int res1 = 0 ;
21933 int val2 ;
21934 int ecode2 = 0 ;
21935 PyObject *swig_obj[2] ;
21936
21937 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21939 if (!SWIG_IsOK(res1)) {
21940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21941 }
21942 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21943 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21944 if (!SWIG_IsOK(ecode2)) {
21945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21946 }
21947 arg2 = static_cast< int >(val2);
21948 if (arg1) (arg1)->m_y = arg2;
21949
21950 resultobj = SWIG_Py_Void();
21951 return resultobj;
21952 fail:
21953 return NULL;
21954 }
21955
21956
21957 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21958 PyObject *resultobj = 0;
21959 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21960 int result;
21961 void *argp1 = 0 ;
21962 int res1 = 0 ;
21963 PyObject *swig_obj[1] ;
21964
21965 if (!args) SWIG_fail;
21966 swig_obj[0] = args;
21967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21968 if (!SWIG_IsOK(res1)) {
21969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21970 }
21971 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21972 result = (int) ((arg1)->m_y);
21973 resultobj = SWIG_From_int(static_cast< int >(result));
21974 return resultobj;
21975 fail:
21976 return NULL;
21977 }
21978
21979
21980 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21981 PyObject *resultobj = 0;
21982 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21983 bool arg2 ;
21984 void *argp1 = 0 ;
21985 int res1 = 0 ;
21986 bool val2 ;
21987 int ecode2 = 0 ;
21988 PyObject *swig_obj[2] ;
21989
21990 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21992 if (!SWIG_IsOK(res1)) {
21993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21994 }
21995 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21996 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21997 if (!SWIG_IsOK(ecode2)) {
21998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21999 }
22000 arg2 = static_cast< bool >(val2);
22001 if (arg1) (arg1)->m_leftDown = arg2;
22002
22003 resultobj = SWIG_Py_Void();
22004 return resultobj;
22005 fail:
22006 return NULL;
22007 }
22008
22009
22010 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22011 PyObject *resultobj = 0;
22012 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22013 bool result;
22014 void *argp1 = 0 ;
22015 int res1 = 0 ;
22016 PyObject *swig_obj[1] ;
22017
22018 if (!args) SWIG_fail;
22019 swig_obj[0] = args;
22020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22021 if (!SWIG_IsOK(res1)) {
22022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22023 }
22024 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22025 result = (bool) ((arg1)->m_leftDown);
22026 {
22027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22028 }
22029 return resultobj;
22030 fail:
22031 return NULL;
22032 }
22033
22034
22035 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22036 PyObject *resultobj = 0;
22037 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22038 bool arg2 ;
22039 void *argp1 = 0 ;
22040 int res1 = 0 ;
22041 bool val2 ;
22042 int ecode2 = 0 ;
22043 PyObject *swig_obj[2] ;
22044
22045 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
22046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22047 if (!SWIG_IsOK(res1)) {
22048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22049 }
22050 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22051 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22052 if (!SWIG_IsOK(ecode2)) {
22053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
22054 }
22055 arg2 = static_cast< bool >(val2);
22056 if (arg1) (arg1)->m_middleDown = arg2;
22057
22058 resultobj = SWIG_Py_Void();
22059 return resultobj;
22060 fail:
22061 return NULL;
22062 }
22063
22064
22065 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22066 PyObject *resultobj = 0;
22067 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22068 bool result;
22069 void *argp1 = 0 ;
22070 int res1 = 0 ;
22071 PyObject *swig_obj[1] ;
22072
22073 if (!args) SWIG_fail;
22074 swig_obj[0] = args;
22075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22076 if (!SWIG_IsOK(res1)) {
22077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22078 }
22079 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22080 result = (bool) ((arg1)->m_middleDown);
22081 {
22082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22083 }
22084 return resultobj;
22085 fail:
22086 return NULL;
22087 }
22088
22089
22090 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22091 PyObject *resultobj = 0;
22092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22093 bool arg2 ;
22094 void *argp1 = 0 ;
22095 int res1 = 0 ;
22096 bool val2 ;
22097 int ecode2 = 0 ;
22098 PyObject *swig_obj[2] ;
22099
22100 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
22101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22102 if (!SWIG_IsOK(res1)) {
22103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22104 }
22105 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22106 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22107 if (!SWIG_IsOK(ecode2)) {
22108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
22109 }
22110 arg2 = static_cast< bool >(val2);
22111 if (arg1) (arg1)->m_rightDown = arg2;
22112
22113 resultobj = SWIG_Py_Void();
22114 return resultobj;
22115 fail:
22116 return NULL;
22117 }
22118
22119
22120 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22121 PyObject *resultobj = 0;
22122 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22123 bool result;
22124 void *argp1 = 0 ;
22125 int res1 = 0 ;
22126 PyObject *swig_obj[1] ;
22127
22128 if (!args) SWIG_fail;
22129 swig_obj[0] = args;
22130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22131 if (!SWIG_IsOK(res1)) {
22132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22133 }
22134 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22135 result = (bool) ((arg1)->m_rightDown);
22136 {
22137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22138 }
22139 return resultobj;
22140 fail:
22141 return NULL;
22142 }
22143
22144
22145 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22146 PyObject *resultobj = 0;
22147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22148 bool arg2 ;
22149 void *argp1 = 0 ;
22150 int res1 = 0 ;
22151 bool val2 ;
22152 int ecode2 = 0 ;
22153 PyObject *swig_obj[2] ;
22154
22155 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22157 if (!SWIG_IsOK(res1)) {
22158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22159 }
22160 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22161 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22162 if (!SWIG_IsOK(ecode2)) {
22163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22164 }
22165 arg2 = static_cast< bool >(val2);
22166 if (arg1) (arg1)->m_controlDown = arg2;
22167
22168 resultobj = SWIG_Py_Void();
22169 return resultobj;
22170 fail:
22171 return NULL;
22172 }
22173
22174
22175 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22176 PyObject *resultobj = 0;
22177 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22178 bool result;
22179 void *argp1 = 0 ;
22180 int res1 = 0 ;
22181 PyObject *swig_obj[1] ;
22182
22183 if (!args) SWIG_fail;
22184 swig_obj[0] = args;
22185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22186 if (!SWIG_IsOK(res1)) {
22187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22188 }
22189 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22190 result = (bool) ((arg1)->m_controlDown);
22191 {
22192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22193 }
22194 return resultobj;
22195 fail:
22196 return NULL;
22197 }
22198
22199
22200 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22201 PyObject *resultobj = 0;
22202 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22203 bool arg2 ;
22204 void *argp1 = 0 ;
22205 int res1 = 0 ;
22206 bool val2 ;
22207 int ecode2 = 0 ;
22208 PyObject *swig_obj[2] ;
22209
22210 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22212 if (!SWIG_IsOK(res1)) {
22213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22214 }
22215 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22216 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22217 if (!SWIG_IsOK(ecode2)) {
22218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22219 }
22220 arg2 = static_cast< bool >(val2);
22221 if (arg1) (arg1)->m_shiftDown = arg2;
22222
22223 resultobj = SWIG_Py_Void();
22224 return resultobj;
22225 fail:
22226 return NULL;
22227 }
22228
22229
22230 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22231 PyObject *resultobj = 0;
22232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22233 bool result;
22234 void *argp1 = 0 ;
22235 int res1 = 0 ;
22236 PyObject *swig_obj[1] ;
22237
22238 if (!args) SWIG_fail;
22239 swig_obj[0] = args;
22240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22241 if (!SWIG_IsOK(res1)) {
22242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22243 }
22244 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22245 result = (bool) ((arg1)->m_shiftDown);
22246 {
22247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22248 }
22249 return resultobj;
22250 fail:
22251 return NULL;
22252 }
22253
22254
22255 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22256 PyObject *resultobj = 0;
22257 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22258 bool arg2 ;
22259 void *argp1 = 0 ;
22260 int res1 = 0 ;
22261 bool val2 ;
22262 int ecode2 = 0 ;
22263 PyObject *swig_obj[2] ;
22264
22265 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22267 if (!SWIG_IsOK(res1)) {
22268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22269 }
22270 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22271 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22272 if (!SWIG_IsOK(ecode2)) {
22273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22274 }
22275 arg2 = static_cast< bool >(val2);
22276 if (arg1) (arg1)->m_altDown = arg2;
22277
22278 resultobj = SWIG_Py_Void();
22279 return resultobj;
22280 fail:
22281 return NULL;
22282 }
22283
22284
22285 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22286 PyObject *resultobj = 0;
22287 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22288 bool result;
22289 void *argp1 = 0 ;
22290 int res1 = 0 ;
22291 PyObject *swig_obj[1] ;
22292
22293 if (!args) SWIG_fail;
22294 swig_obj[0] = args;
22295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22296 if (!SWIG_IsOK(res1)) {
22297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22298 }
22299 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22300 result = (bool) ((arg1)->m_altDown);
22301 {
22302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22303 }
22304 return resultobj;
22305 fail:
22306 return NULL;
22307 }
22308
22309
22310 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22311 PyObject *resultobj = 0;
22312 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22313 bool arg2 ;
22314 void *argp1 = 0 ;
22315 int res1 = 0 ;
22316 bool val2 ;
22317 int ecode2 = 0 ;
22318 PyObject *swig_obj[2] ;
22319
22320 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22322 if (!SWIG_IsOK(res1)) {
22323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22324 }
22325 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22326 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22327 if (!SWIG_IsOK(ecode2)) {
22328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22329 }
22330 arg2 = static_cast< bool >(val2);
22331 if (arg1) (arg1)->m_metaDown = arg2;
22332
22333 resultobj = SWIG_Py_Void();
22334 return resultobj;
22335 fail:
22336 return NULL;
22337 }
22338
22339
22340 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22341 PyObject *resultobj = 0;
22342 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22343 bool result;
22344 void *argp1 = 0 ;
22345 int res1 = 0 ;
22346 PyObject *swig_obj[1] ;
22347
22348 if (!args) SWIG_fail;
22349 swig_obj[0] = args;
22350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22351 if (!SWIG_IsOK(res1)) {
22352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22353 }
22354 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22355 result = (bool) ((arg1)->m_metaDown);
22356 {
22357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22358 }
22359 return resultobj;
22360 fail:
22361 return NULL;
22362 }
22363
22364
22365 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22366 PyObject *resultobj = 0;
22367 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22368 int arg2 ;
22369 void *argp1 = 0 ;
22370 int res1 = 0 ;
22371 int val2 ;
22372 int ecode2 = 0 ;
22373 PyObject *swig_obj[2] ;
22374
22375 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
22376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22377 if (!SWIG_IsOK(res1)) {
22378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22379 }
22380 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22381 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22382 if (!SWIG_IsOK(ecode2)) {
22383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
22384 }
22385 arg2 = static_cast< int >(val2);
22386 if (arg1) (arg1)->m_wheelRotation = arg2;
22387
22388 resultobj = SWIG_Py_Void();
22389 return resultobj;
22390 fail:
22391 return NULL;
22392 }
22393
22394
22395 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22396 PyObject *resultobj = 0;
22397 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22398 int result;
22399 void *argp1 = 0 ;
22400 int res1 = 0 ;
22401 PyObject *swig_obj[1] ;
22402
22403 if (!args) SWIG_fail;
22404 swig_obj[0] = args;
22405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22406 if (!SWIG_IsOK(res1)) {
22407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22408 }
22409 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22410 result = (int) ((arg1)->m_wheelRotation);
22411 resultobj = SWIG_From_int(static_cast< int >(result));
22412 return resultobj;
22413 fail:
22414 return NULL;
22415 }
22416
22417
22418 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22419 PyObject *resultobj = 0;
22420 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22421 int arg2 ;
22422 void *argp1 = 0 ;
22423 int res1 = 0 ;
22424 int val2 ;
22425 int ecode2 = 0 ;
22426 PyObject *swig_obj[2] ;
22427
22428 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
22429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22430 if (!SWIG_IsOK(res1)) {
22431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22432 }
22433 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22434 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22435 if (!SWIG_IsOK(ecode2)) {
22436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
22437 }
22438 arg2 = static_cast< int >(val2);
22439 if (arg1) (arg1)->m_wheelDelta = arg2;
22440
22441 resultobj = SWIG_Py_Void();
22442 return resultobj;
22443 fail:
22444 return NULL;
22445 }
22446
22447
22448 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22449 PyObject *resultobj = 0;
22450 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22451 int result;
22452 void *argp1 = 0 ;
22453 int res1 = 0 ;
22454 PyObject *swig_obj[1] ;
22455
22456 if (!args) SWIG_fail;
22457 swig_obj[0] = args;
22458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22459 if (!SWIG_IsOK(res1)) {
22460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22461 }
22462 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22463 result = (int) ((arg1)->m_wheelDelta);
22464 resultobj = SWIG_From_int(static_cast< int >(result));
22465 return resultobj;
22466 fail:
22467 return NULL;
22468 }
22469
22470
22471 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22472 PyObject *resultobj = 0;
22473 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22474 int arg2 ;
22475 void *argp1 = 0 ;
22476 int res1 = 0 ;
22477 int val2 ;
22478 int ecode2 = 0 ;
22479 PyObject *swig_obj[2] ;
22480
22481 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
22482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22483 if (!SWIG_IsOK(res1)) {
22484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22485 }
22486 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22487 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22488 if (!SWIG_IsOK(ecode2)) {
22489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
22490 }
22491 arg2 = static_cast< int >(val2);
22492 if (arg1) (arg1)->m_linesPerAction = arg2;
22493
22494 resultobj = SWIG_Py_Void();
22495 return resultobj;
22496 fail:
22497 return NULL;
22498 }
22499
22500
22501 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22502 PyObject *resultobj = 0;
22503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22504 int result;
22505 void *argp1 = 0 ;
22506 int res1 = 0 ;
22507 PyObject *swig_obj[1] ;
22508
22509 if (!args) SWIG_fail;
22510 swig_obj[0] = args;
22511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22512 if (!SWIG_IsOK(res1)) {
22513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22514 }
22515 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22516 result = (int) ((arg1)->m_linesPerAction);
22517 resultobj = SWIG_From_int(static_cast< int >(result));
22518 return resultobj;
22519 fail:
22520 return NULL;
22521 }
22522
22523
22524 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22525 PyObject *obj;
22526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22527 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
22528 return SWIG_Py_Void();
22529 }
22530
22531 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22532 return SWIG_Python_InitShadowInstance(args);
22533 }
22534
22535 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22536 PyObject *resultobj = 0;
22537 int arg1 = (int) 0 ;
22538 int arg2 = (int) 0 ;
22539 wxSetCursorEvent *result = 0 ;
22540 int val1 ;
22541 int ecode1 = 0 ;
22542 int val2 ;
22543 int ecode2 = 0 ;
22544 PyObject * obj0 = 0 ;
22545 PyObject * obj1 = 0 ;
22546 char * kwnames[] = {
22547 (char *) "x",(char *) "y", NULL
22548 };
22549
22550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22551 if (obj0) {
22552 ecode1 = SWIG_AsVal_int(obj0, &val1);
22553 if (!SWIG_IsOK(ecode1)) {
22554 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
22555 }
22556 arg1 = static_cast< int >(val1);
22557 }
22558 if (obj1) {
22559 ecode2 = SWIG_AsVal_int(obj1, &val2);
22560 if (!SWIG_IsOK(ecode2)) {
22561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
22562 }
22563 arg2 = static_cast< int >(val2);
22564 }
22565 {
22566 PyThreadState* __tstate = wxPyBeginAllowThreads();
22567 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
22568 wxPyEndAllowThreads(__tstate);
22569 if (PyErr_Occurred()) SWIG_fail;
22570 }
22571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
22572 return resultobj;
22573 fail:
22574 return NULL;
22575 }
22576
22577
22578 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22579 PyObject *resultobj = 0;
22580 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22581 int result;
22582 void *argp1 = 0 ;
22583 int res1 = 0 ;
22584 PyObject *swig_obj[1] ;
22585
22586 if (!args) SWIG_fail;
22587 swig_obj[0] = args;
22588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22589 if (!SWIG_IsOK(res1)) {
22590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22591 }
22592 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22593 {
22594 PyThreadState* __tstate = wxPyBeginAllowThreads();
22595 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22596 wxPyEndAllowThreads(__tstate);
22597 if (PyErr_Occurred()) SWIG_fail;
22598 }
22599 resultobj = SWIG_From_int(static_cast< int >(result));
22600 return resultobj;
22601 fail:
22602 return NULL;
22603 }
22604
22605
22606 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22607 PyObject *resultobj = 0;
22608 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22609 int result;
22610 void *argp1 = 0 ;
22611 int res1 = 0 ;
22612 PyObject *swig_obj[1] ;
22613
22614 if (!args) SWIG_fail;
22615 swig_obj[0] = args;
22616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22617 if (!SWIG_IsOK(res1)) {
22618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22619 }
22620 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22621 {
22622 PyThreadState* __tstate = wxPyBeginAllowThreads();
22623 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22624 wxPyEndAllowThreads(__tstate);
22625 if (PyErr_Occurred()) SWIG_fail;
22626 }
22627 resultobj = SWIG_From_int(static_cast< int >(result));
22628 return resultobj;
22629 fail:
22630 return NULL;
22631 }
22632
22633
22634 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22635 PyObject *resultobj = 0;
22636 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22637 wxCursor *arg2 = 0 ;
22638 void *argp1 = 0 ;
22639 int res1 = 0 ;
22640 void *argp2 = 0 ;
22641 int res2 = 0 ;
22642 PyObject * obj0 = 0 ;
22643 PyObject * obj1 = 0 ;
22644 char * kwnames[] = {
22645 (char *) "self",(char *) "cursor", NULL
22646 };
22647
22648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22650 if (!SWIG_IsOK(res1)) {
22651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22652 }
22653 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22654 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22655 if (!SWIG_IsOK(res2)) {
22656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22657 }
22658 if (!argp2) {
22659 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22660 }
22661 arg2 = reinterpret_cast< wxCursor * >(argp2);
22662 {
22663 PyThreadState* __tstate = wxPyBeginAllowThreads();
22664 (arg1)->SetCursor((wxCursor const &)*arg2);
22665 wxPyEndAllowThreads(__tstate);
22666 if (PyErr_Occurred()) SWIG_fail;
22667 }
22668 resultobj = SWIG_Py_Void();
22669 return resultobj;
22670 fail:
22671 return NULL;
22672 }
22673
22674
22675 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22676 PyObject *resultobj = 0;
22677 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22678 wxCursor *result = 0 ;
22679 void *argp1 = 0 ;
22680 int res1 = 0 ;
22681 PyObject *swig_obj[1] ;
22682
22683 if (!args) SWIG_fail;
22684 swig_obj[0] = args;
22685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22686 if (!SWIG_IsOK(res1)) {
22687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22688 }
22689 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22690 {
22691 PyThreadState* __tstate = wxPyBeginAllowThreads();
22692 {
22693 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22694 result = (wxCursor *) &_result_ref;
22695 }
22696 wxPyEndAllowThreads(__tstate);
22697 if (PyErr_Occurred()) SWIG_fail;
22698 }
22699 {
22700 wxCursor* resultptr = new wxCursor(*result);
22701 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22702 }
22703 return resultobj;
22704 fail:
22705 return NULL;
22706 }
22707
22708
22709 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22710 PyObject *resultobj = 0;
22711 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22712 bool result;
22713 void *argp1 = 0 ;
22714 int res1 = 0 ;
22715 PyObject *swig_obj[1] ;
22716
22717 if (!args) SWIG_fail;
22718 swig_obj[0] = args;
22719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22720 if (!SWIG_IsOK(res1)) {
22721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22722 }
22723 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22724 {
22725 PyThreadState* __tstate = wxPyBeginAllowThreads();
22726 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22727 wxPyEndAllowThreads(__tstate);
22728 if (PyErr_Occurred()) SWIG_fail;
22729 }
22730 {
22731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22732 }
22733 return resultobj;
22734 fail:
22735 return NULL;
22736 }
22737
22738
22739 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22740 PyObject *obj;
22741 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22742 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22743 return SWIG_Py_Void();
22744 }
22745
22746 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22747 return SWIG_Python_InitShadowInstance(args);
22748 }
22749
22750 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22751 PyObject *resultobj = 0;
22752 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22753 wxKeyEvent *result = 0 ;
22754 int val1 ;
22755 int ecode1 = 0 ;
22756 PyObject * obj0 = 0 ;
22757 char * kwnames[] = {
22758 (char *) "eventType", NULL
22759 };
22760
22761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22762 if (obj0) {
22763 ecode1 = SWIG_AsVal_int(obj0, &val1);
22764 if (!SWIG_IsOK(ecode1)) {
22765 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22766 }
22767 arg1 = static_cast< wxEventType >(val1);
22768 }
22769 {
22770 PyThreadState* __tstate = wxPyBeginAllowThreads();
22771 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22772 wxPyEndAllowThreads(__tstate);
22773 if (PyErr_Occurred()) SWIG_fail;
22774 }
22775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22776 return resultobj;
22777 fail:
22778 return NULL;
22779 }
22780
22781
22782 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22783 PyObject *resultobj = 0;
22784 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22785 int result;
22786 void *argp1 = 0 ;
22787 int res1 = 0 ;
22788 PyObject *swig_obj[1] ;
22789
22790 if (!args) SWIG_fail;
22791 swig_obj[0] = args;
22792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22793 if (!SWIG_IsOK(res1)) {
22794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22795 }
22796 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22797 {
22798 PyThreadState* __tstate = wxPyBeginAllowThreads();
22799 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22800 wxPyEndAllowThreads(__tstate);
22801 if (PyErr_Occurred()) SWIG_fail;
22802 }
22803 resultobj = SWIG_From_int(static_cast< int >(result));
22804 return resultobj;
22805 fail:
22806 return NULL;
22807 }
22808
22809
22810 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22811 PyObject *resultobj = 0;
22812 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22813 bool result;
22814 void *argp1 = 0 ;
22815 int res1 = 0 ;
22816 PyObject *swig_obj[1] ;
22817
22818 if (!args) SWIG_fail;
22819 swig_obj[0] = args;
22820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22821 if (!SWIG_IsOK(res1)) {
22822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22823 }
22824 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22825 {
22826 PyThreadState* __tstate = wxPyBeginAllowThreads();
22827 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22828 wxPyEndAllowThreads(__tstate);
22829 if (PyErr_Occurred()) SWIG_fail;
22830 }
22831 {
22832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22833 }
22834 return resultobj;
22835 fail:
22836 return NULL;
22837 }
22838
22839
22840 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22841 PyObject *resultobj = 0;
22842 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22843 bool result;
22844 void *argp1 = 0 ;
22845 int res1 = 0 ;
22846 PyObject *swig_obj[1] ;
22847
22848 if (!args) SWIG_fail;
22849 swig_obj[0] = args;
22850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22851 if (!SWIG_IsOK(res1)) {
22852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22853 }
22854 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22855 {
22856 PyThreadState* __tstate = wxPyBeginAllowThreads();
22857 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22858 wxPyEndAllowThreads(__tstate);
22859 if (PyErr_Occurred()) SWIG_fail;
22860 }
22861 {
22862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22863 }
22864 return resultobj;
22865 fail:
22866 return NULL;
22867 }
22868
22869
22870 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22871 PyObject *resultobj = 0;
22872 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22873 bool result;
22874 void *argp1 = 0 ;
22875 int res1 = 0 ;
22876 PyObject *swig_obj[1] ;
22877
22878 if (!args) SWIG_fail;
22879 swig_obj[0] = args;
22880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22881 if (!SWIG_IsOK(res1)) {
22882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22883 }
22884 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22885 {
22886 PyThreadState* __tstate = wxPyBeginAllowThreads();
22887 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22888 wxPyEndAllowThreads(__tstate);
22889 if (PyErr_Occurred()) SWIG_fail;
22890 }
22891 {
22892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22893 }
22894 return resultobj;
22895 fail:
22896 return NULL;
22897 }
22898
22899
22900 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22901 PyObject *resultobj = 0;
22902 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22903 bool result;
22904 void *argp1 = 0 ;
22905 int res1 = 0 ;
22906 PyObject *swig_obj[1] ;
22907
22908 if (!args) SWIG_fail;
22909 swig_obj[0] = args;
22910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22911 if (!SWIG_IsOK(res1)) {
22912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22913 }
22914 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22915 {
22916 PyThreadState* __tstate = wxPyBeginAllowThreads();
22917 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22918 wxPyEndAllowThreads(__tstate);
22919 if (PyErr_Occurred()) SWIG_fail;
22920 }
22921 {
22922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22923 }
22924 return resultobj;
22925 fail:
22926 return NULL;
22927 }
22928
22929
22930 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22931 PyObject *resultobj = 0;
22932 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22933 bool result;
22934 void *argp1 = 0 ;
22935 int res1 = 0 ;
22936 PyObject *swig_obj[1] ;
22937
22938 if (!args) SWIG_fail;
22939 swig_obj[0] = args;
22940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22941 if (!SWIG_IsOK(res1)) {
22942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22943 }
22944 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22945 {
22946 PyThreadState* __tstate = wxPyBeginAllowThreads();
22947 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22948 wxPyEndAllowThreads(__tstate);
22949 if (PyErr_Occurred()) SWIG_fail;
22950 }
22951 {
22952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22953 }
22954 return resultobj;
22955 fail:
22956 return NULL;
22957 }
22958
22959
22960 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22961 PyObject *resultobj = 0;
22962 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22963 bool 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_wxKeyEvent, 0 | 0 );
22971 if (!SWIG_IsOK(res1)) {
22972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22973 }
22974 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22975 {
22976 PyThreadState* __tstate = wxPyBeginAllowThreads();
22977 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22978 wxPyEndAllowThreads(__tstate);
22979 if (PyErr_Occurred()) SWIG_fail;
22980 }
22981 {
22982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22983 }
22984 return resultobj;
22985 fail:
22986 return NULL;
22987 }
22988
22989
22990 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22991 PyObject *resultobj = 0;
22992 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22993 int result;
22994 void *argp1 = 0 ;
22995 int res1 = 0 ;
22996 PyObject *swig_obj[1] ;
22997
22998 if (!args) SWIG_fail;
22999 swig_obj[0] = args;
23000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23001 if (!SWIG_IsOK(res1)) {
23002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23003 }
23004 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23005 {
23006 PyThreadState* __tstate = wxPyBeginAllowThreads();
23007 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
23008 wxPyEndAllowThreads(__tstate);
23009 if (PyErr_Occurred()) SWIG_fail;
23010 }
23011 resultobj = SWIG_From_int(static_cast< int >(result));
23012 return resultobj;
23013 fail:
23014 return NULL;
23015 }
23016
23017
23018 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23019 PyObject *resultobj = 0;
23020 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23021 int result;
23022 void *argp1 = 0 ;
23023 int res1 = 0 ;
23024 PyObject *swig_obj[1] ;
23025
23026 if (!args) SWIG_fail;
23027 swig_obj[0] = args;
23028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23029 if (!SWIG_IsOK(res1)) {
23030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23031 }
23032 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23033 {
23034 PyThreadState* __tstate = wxPyBeginAllowThreads();
23035 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
23036 wxPyEndAllowThreads(__tstate);
23037 if (PyErr_Occurred()) SWIG_fail;
23038 }
23039 resultobj = SWIG_From_int(static_cast< int >(result));
23040 return resultobj;
23041 fail:
23042 return NULL;
23043 }
23044
23045
23046 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23047 PyObject *resultobj = 0;
23048 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23049 int arg2 ;
23050 void *argp1 = 0 ;
23051 int res1 = 0 ;
23052 int val2 ;
23053 int ecode2 = 0 ;
23054 PyObject * obj0 = 0 ;
23055 PyObject * obj1 = 0 ;
23056 char * kwnames[] = {
23057 (char *) "self",(char *) "uniChar", NULL
23058 };
23059
23060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
23061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23062 if (!SWIG_IsOK(res1)) {
23063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23064 }
23065 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23066 ecode2 = SWIG_AsVal_int(obj1, &val2);
23067 if (!SWIG_IsOK(ecode2)) {
23068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
23069 }
23070 arg2 = static_cast< int >(val2);
23071 {
23072 PyThreadState* __tstate = wxPyBeginAllowThreads();
23073 wxKeyEvent_SetUnicodeKey(arg1,arg2);
23074 wxPyEndAllowThreads(__tstate);
23075 if (PyErr_Occurred()) SWIG_fail;
23076 }
23077 resultobj = SWIG_Py_Void();
23078 return resultobj;
23079 fail:
23080 return NULL;
23081 }
23082
23083
23084 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23085 PyObject *resultobj = 0;
23086 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23087 unsigned int result;
23088 void *argp1 = 0 ;
23089 int res1 = 0 ;
23090 PyObject *swig_obj[1] ;
23091
23092 if (!args) SWIG_fail;
23093 swig_obj[0] = args;
23094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23095 if (!SWIG_IsOK(res1)) {
23096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23097 }
23098 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23099 {
23100 PyThreadState* __tstate = wxPyBeginAllowThreads();
23101 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
23102 wxPyEndAllowThreads(__tstate);
23103 if (PyErr_Occurred()) SWIG_fail;
23104 }
23105 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23106 return resultobj;
23107 fail:
23108 return NULL;
23109 }
23110
23111
23112 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23113 PyObject *resultobj = 0;
23114 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23115 unsigned int result;
23116 void *argp1 = 0 ;
23117 int res1 = 0 ;
23118 PyObject *swig_obj[1] ;
23119
23120 if (!args) SWIG_fail;
23121 swig_obj[0] = args;
23122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23123 if (!SWIG_IsOK(res1)) {
23124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23125 }
23126 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23127 {
23128 PyThreadState* __tstate = wxPyBeginAllowThreads();
23129 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
23130 wxPyEndAllowThreads(__tstate);
23131 if (PyErr_Occurred()) SWIG_fail;
23132 }
23133 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23134 return resultobj;
23135 fail:
23136 return NULL;
23137 }
23138
23139
23140 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23141 PyObject *resultobj = 0;
23142 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23143 wxPoint result;
23144 void *argp1 = 0 ;
23145 int res1 = 0 ;
23146 PyObject *swig_obj[1] ;
23147
23148 if (!args) SWIG_fail;
23149 swig_obj[0] = args;
23150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23151 if (!SWIG_IsOK(res1)) {
23152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23153 }
23154 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23155 {
23156 PyThreadState* __tstate = wxPyBeginAllowThreads();
23157 result = (arg1)->GetPosition();
23158 wxPyEndAllowThreads(__tstate);
23159 if (PyErr_Occurred()) SWIG_fail;
23160 }
23161 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23162 return resultobj;
23163 fail:
23164 return NULL;
23165 }
23166
23167
23168 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23169 PyObject *resultobj = 0;
23170 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23171 long *arg2 = (long *) 0 ;
23172 long *arg3 = (long *) 0 ;
23173 void *argp1 = 0 ;
23174 int res1 = 0 ;
23175 long temp2 ;
23176 int res2 = SWIG_TMPOBJ ;
23177 long temp3 ;
23178 int res3 = SWIG_TMPOBJ ;
23179 PyObject *swig_obj[1] ;
23180
23181 arg2 = &temp2;
23182 arg3 = &temp3;
23183 if (!args) SWIG_fail;
23184 swig_obj[0] = args;
23185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23186 if (!SWIG_IsOK(res1)) {
23187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23188 }
23189 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23190 {
23191 PyThreadState* __tstate = wxPyBeginAllowThreads();
23192 (arg1)->GetPosition(arg2,arg3);
23193 wxPyEndAllowThreads(__tstate);
23194 if (PyErr_Occurred()) SWIG_fail;
23195 }
23196 resultobj = SWIG_Py_Void();
23197 if (SWIG_IsTmpObj(res2)) {
23198 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23199 } else {
23200 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23201 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23202 }
23203 if (SWIG_IsTmpObj(res3)) {
23204 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23205 } else {
23206 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23207 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23208 }
23209 return resultobj;
23210 fail:
23211 return NULL;
23212 }
23213
23214
23215 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23216 PyObject *resultobj = 0;
23217 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23218 int result;
23219 void *argp1 = 0 ;
23220 int res1 = 0 ;
23221 PyObject *swig_obj[1] ;
23222
23223 if (!args) SWIG_fail;
23224 swig_obj[0] = args;
23225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23226 if (!SWIG_IsOK(res1)) {
23227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23228 }
23229 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23230 {
23231 PyThreadState* __tstate = wxPyBeginAllowThreads();
23232 result = (int)((wxKeyEvent const *)arg1)->GetX();
23233 wxPyEndAllowThreads(__tstate);
23234 if (PyErr_Occurred()) SWIG_fail;
23235 }
23236 resultobj = SWIG_From_int(static_cast< int >(result));
23237 return resultobj;
23238 fail:
23239 return NULL;
23240 }
23241
23242
23243 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23244 PyObject *resultobj = 0;
23245 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23246 int result;
23247 void *argp1 = 0 ;
23248 int res1 = 0 ;
23249 PyObject *swig_obj[1] ;
23250
23251 if (!args) SWIG_fail;
23252 swig_obj[0] = args;
23253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23254 if (!SWIG_IsOK(res1)) {
23255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23256 }
23257 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23258 {
23259 PyThreadState* __tstate = wxPyBeginAllowThreads();
23260 result = (int)((wxKeyEvent const *)arg1)->GetY();
23261 wxPyEndAllowThreads(__tstate);
23262 if (PyErr_Occurred()) SWIG_fail;
23263 }
23264 resultobj = SWIG_From_int(static_cast< int >(result));
23265 return resultobj;
23266 fail:
23267 return NULL;
23268 }
23269
23270
23271 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23272 PyObject *resultobj = 0;
23273 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23274 int arg2 ;
23275 void *argp1 = 0 ;
23276 int res1 = 0 ;
23277 int val2 ;
23278 int ecode2 = 0 ;
23279 PyObject *swig_obj[2] ;
23280
23281 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23283 if (!SWIG_IsOK(res1)) {
23284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23285 }
23286 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23287 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23288 if (!SWIG_IsOK(ecode2)) {
23289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23290 }
23291 arg2 = static_cast< int >(val2);
23292 if (arg1) (arg1)->m_x = arg2;
23293
23294 resultobj = SWIG_Py_Void();
23295 return resultobj;
23296 fail:
23297 return NULL;
23298 }
23299
23300
23301 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23302 PyObject *resultobj = 0;
23303 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23304 int result;
23305 void *argp1 = 0 ;
23306 int res1 = 0 ;
23307 PyObject *swig_obj[1] ;
23308
23309 if (!args) SWIG_fail;
23310 swig_obj[0] = args;
23311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23312 if (!SWIG_IsOK(res1)) {
23313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23314 }
23315 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23316 result = (int) ((arg1)->m_x);
23317 resultobj = SWIG_From_int(static_cast< int >(result));
23318 return resultobj;
23319 fail:
23320 return NULL;
23321 }
23322
23323
23324 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23325 PyObject *resultobj = 0;
23326 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23327 int arg2 ;
23328 void *argp1 = 0 ;
23329 int res1 = 0 ;
23330 int val2 ;
23331 int ecode2 = 0 ;
23332 PyObject *swig_obj[2] ;
23333
23334 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
23335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23336 if (!SWIG_IsOK(res1)) {
23337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23338 }
23339 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23340 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23341 if (!SWIG_IsOK(ecode2)) {
23342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
23343 }
23344 arg2 = static_cast< int >(val2);
23345 if (arg1) (arg1)->m_y = arg2;
23346
23347 resultobj = SWIG_Py_Void();
23348 return resultobj;
23349 fail:
23350 return NULL;
23351 }
23352
23353
23354 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23355 PyObject *resultobj = 0;
23356 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23357 int result;
23358 void *argp1 = 0 ;
23359 int res1 = 0 ;
23360 PyObject *swig_obj[1] ;
23361
23362 if (!args) SWIG_fail;
23363 swig_obj[0] = args;
23364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23365 if (!SWIG_IsOK(res1)) {
23366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23367 }
23368 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23369 result = (int) ((arg1)->m_y);
23370 resultobj = SWIG_From_int(static_cast< int >(result));
23371 return resultobj;
23372 fail:
23373 return NULL;
23374 }
23375
23376
23377 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23378 PyObject *resultobj = 0;
23379 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23380 long arg2 ;
23381 void *argp1 = 0 ;
23382 int res1 = 0 ;
23383 long val2 ;
23384 int ecode2 = 0 ;
23385 PyObject *swig_obj[2] ;
23386
23387 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
23388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23389 if (!SWIG_IsOK(res1)) {
23390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23391 }
23392 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23393 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
23394 if (!SWIG_IsOK(ecode2)) {
23395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
23396 }
23397 arg2 = static_cast< long >(val2);
23398 if (arg1) (arg1)->m_keyCode = arg2;
23399
23400 resultobj = SWIG_Py_Void();
23401 return resultobj;
23402 fail:
23403 return NULL;
23404 }
23405
23406
23407 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23408 PyObject *resultobj = 0;
23409 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23410 long result;
23411 void *argp1 = 0 ;
23412 int res1 = 0 ;
23413 PyObject *swig_obj[1] ;
23414
23415 if (!args) SWIG_fail;
23416 swig_obj[0] = args;
23417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23418 if (!SWIG_IsOK(res1)) {
23419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23420 }
23421 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23422 result = (long) ((arg1)->m_keyCode);
23423 resultobj = SWIG_From_long(static_cast< long >(result));
23424 return resultobj;
23425 fail:
23426 return NULL;
23427 }
23428
23429
23430 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23431 PyObject *resultobj = 0;
23432 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23433 bool arg2 ;
23434 void *argp1 = 0 ;
23435 int res1 = 0 ;
23436 bool val2 ;
23437 int ecode2 = 0 ;
23438 PyObject *swig_obj[2] ;
23439
23440 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
23441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23442 if (!SWIG_IsOK(res1)) {
23443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23444 }
23445 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23446 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23447 if (!SWIG_IsOK(ecode2)) {
23448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
23449 }
23450 arg2 = static_cast< bool >(val2);
23451 if (arg1) (arg1)->m_controlDown = arg2;
23452
23453 resultobj = SWIG_Py_Void();
23454 return resultobj;
23455 fail:
23456 return NULL;
23457 }
23458
23459
23460 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23461 PyObject *resultobj = 0;
23462 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23463 bool result;
23464 void *argp1 = 0 ;
23465 int res1 = 0 ;
23466 PyObject *swig_obj[1] ;
23467
23468 if (!args) SWIG_fail;
23469 swig_obj[0] = args;
23470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23471 if (!SWIG_IsOK(res1)) {
23472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23473 }
23474 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23475 result = (bool) ((arg1)->m_controlDown);
23476 {
23477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23478 }
23479 return resultobj;
23480 fail:
23481 return NULL;
23482 }
23483
23484
23485 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23486 PyObject *resultobj = 0;
23487 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23488 bool arg2 ;
23489 void *argp1 = 0 ;
23490 int res1 = 0 ;
23491 bool val2 ;
23492 int ecode2 = 0 ;
23493 PyObject *swig_obj[2] ;
23494
23495 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
23496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23497 if (!SWIG_IsOK(res1)) {
23498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23499 }
23500 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23501 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23502 if (!SWIG_IsOK(ecode2)) {
23503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
23504 }
23505 arg2 = static_cast< bool >(val2);
23506 if (arg1) (arg1)->m_shiftDown = arg2;
23507
23508 resultobj = SWIG_Py_Void();
23509 return resultobj;
23510 fail:
23511 return NULL;
23512 }
23513
23514
23515 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23516 PyObject *resultobj = 0;
23517 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23518 bool result;
23519 void *argp1 = 0 ;
23520 int res1 = 0 ;
23521 PyObject *swig_obj[1] ;
23522
23523 if (!args) SWIG_fail;
23524 swig_obj[0] = args;
23525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23526 if (!SWIG_IsOK(res1)) {
23527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23528 }
23529 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23530 result = (bool) ((arg1)->m_shiftDown);
23531 {
23532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23533 }
23534 return resultobj;
23535 fail:
23536 return NULL;
23537 }
23538
23539
23540 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23541 PyObject *resultobj = 0;
23542 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23543 bool arg2 ;
23544 void *argp1 = 0 ;
23545 int res1 = 0 ;
23546 bool val2 ;
23547 int ecode2 = 0 ;
23548 PyObject *swig_obj[2] ;
23549
23550 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
23551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23552 if (!SWIG_IsOK(res1)) {
23553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23554 }
23555 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23556 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23557 if (!SWIG_IsOK(ecode2)) {
23558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
23559 }
23560 arg2 = static_cast< bool >(val2);
23561 if (arg1) (arg1)->m_altDown = arg2;
23562
23563 resultobj = SWIG_Py_Void();
23564 return resultobj;
23565 fail:
23566 return NULL;
23567 }
23568
23569
23570 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23571 PyObject *resultobj = 0;
23572 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23573 bool result;
23574 void *argp1 = 0 ;
23575 int res1 = 0 ;
23576 PyObject *swig_obj[1] ;
23577
23578 if (!args) SWIG_fail;
23579 swig_obj[0] = args;
23580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23581 if (!SWIG_IsOK(res1)) {
23582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23583 }
23584 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23585 result = (bool) ((arg1)->m_altDown);
23586 {
23587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23588 }
23589 return resultobj;
23590 fail:
23591 return NULL;
23592 }
23593
23594
23595 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23596 PyObject *resultobj = 0;
23597 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23598 bool arg2 ;
23599 void *argp1 = 0 ;
23600 int res1 = 0 ;
23601 bool val2 ;
23602 int ecode2 = 0 ;
23603 PyObject *swig_obj[2] ;
23604
23605 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23607 if (!SWIG_IsOK(res1)) {
23608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23609 }
23610 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23611 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23612 if (!SWIG_IsOK(ecode2)) {
23613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23614 }
23615 arg2 = static_cast< bool >(val2);
23616 if (arg1) (arg1)->m_metaDown = arg2;
23617
23618 resultobj = SWIG_Py_Void();
23619 return resultobj;
23620 fail:
23621 return NULL;
23622 }
23623
23624
23625 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23626 PyObject *resultobj = 0;
23627 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23628 bool result;
23629 void *argp1 = 0 ;
23630 int res1 = 0 ;
23631 PyObject *swig_obj[1] ;
23632
23633 if (!args) SWIG_fail;
23634 swig_obj[0] = args;
23635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23636 if (!SWIG_IsOK(res1)) {
23637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23638 }
23639 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23640 result = (bool) ((arg1)->m_metaDown);
23641 {
23642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23643 }
23644 return resultobj;
23645 fail:
23646 return NULL;
23647 }
23648
23649
23650 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23651 PyObject *resultobj = 0;
23652 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23653 bool arg2 ;
23654 void *argp1 = 0 ;
23655 int res1 = 0 ;
23656 bool val2 ;
23657 int ecode2 = 0 ;
23658 PyObject *swig_obj[2] ;
23659
23660 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23662 if (!SWIG_IsOK(res1)) {
23663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23664 }
23665 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23666 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23667 if (!SWIG_IsOK(ecode2)) {
23668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23669 }
23670 arg2 = static_cast< bool >(val2);
23671 if (arg1) (arg1)->m_scanCode = arg2;
23672
23673 resultobj = SWIG_Py_Void();
23674 return resultobj;
23675 fail:
23676 return NULL;
23677 }
23678
23679
23680 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23681 PyObject *resultobj = 0;
23682 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23683 bool result;
23684 void *argp1 = 0 ;
23685 int res1 = 0 ;
23686 PyObject *swig_obj[1] ;
23687
23688 if (!args) SWIG_fail;
23689 swig_obj[0] = args;
23690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23691 if (!SWIG_IsOK(res1)) {
23692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23693 }
23694 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23695 result = (bool) ((arg1)->m_scanCode);
23696 {
23697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23698 }
23699 return resultobj;
23700 fail:
23701 return NULL;
23702 }
23703
23704
23705 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23706 PyObject *resultobj = 0;
23707 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23708 unsigned int arg2 ;
23709 void *argp1 = 0 ;
23710 int res1 = 0 ;
23711 unsigned int val2 ;
23712 int ecode2 = 0 ;
23713 PyObject *swig_obj[2] ;
23714
23715 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23717 if (!SWIG_IsOK(res1)) {
23718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23719 }
23720 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23721 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23722 if (!SWIG_IsOK(ecode2)) {
23723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23724 }
23725 arg2 = static_cast< unsigned int >(val2);
23726 if (arg1) (arg1)->m_rawCode = arg2;
23727
23728 resultobj = SWIG_Py_Void();
23729 return resultobj;
23730 fail:
23731 return NULL;
23732 }
23733
23734
23735 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23736 PyObject *resultobj = 0;
23737 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23738 unsigned int result;
23739 void *argp1 = 0 ;
23740 int res1 = 0 ;
23741 PyObject *swig_obj[1] ;
23742
23743 if (!args) SWIG_fail;
23744 swig_obj[0] = args;
23745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23746 if (!SWIG_IsOK(res1)) {
23747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23748 }
23749 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23750 result = (unsigned int) ((arg1)->m_rawCode);
23751 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23752 return resultobj;
23753 fail:
23754 return NULL;
23755 }
23756
23757
23758 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23759 PyObject *resultobj = 0;
23760 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23761 unsigned int arg2 ;
23762 void *argp1 = 0 ;
23763 int res1 = 0 ;
23764 unsigned int val2 ;
23765 int ecode2 = 0 ;
23766 PyObject *swig_obj[2] ;
23767
23768 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23770 if (!SWIG_IsOK(res1)) {
23771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23772 }
23773 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23774 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23775 if (!SWIG_IsOK(ecode2)) {
23776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23777 }
23778 arg2 = static_cast< unsigned int >(val2);
23779 if (arg1) (arg1)->m_rawFlags = arg2;
23780
23781 resultobj = SWIG_Py_Void();
23782 return resultobj;
23783 fail:
23784 return NULL;
23785 }
23786
23787
23788 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23789 PyObject *resultobj = 0;
23790 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23791 unsigned int result;
23792 void *argp1 = 0 ;
23793 int res1 = 0 ;
23794 PyObject *swig_obj[1] ;
23795
23796 if (!args) SWIG_fail;
23797 swig_obj[0] = args;
23798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23799 if (!SWIG_IsOK(res1)) {
23800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23801 }
23802 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23803 result = (unsigned int) ((arg1)->m_rawFlags);
23804 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23805 return resultobj;
23806 fail:
23807 return NULL;
23808 }
23809
23810
23811 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23812 PyObject *obj;
23813 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23814 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23815 return SWIG_Py_Void();
23816 }
23817
23818 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23819 return SWIG_Python_InitShadowInstance(args);
23820 }
23821
23822 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23823 PyObject *resultobj = 0;
23824 wxSize const &arg1_defvalue = wxDefaultSize ;
23825 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23826 int arg2 = (int) 0 ;
23827 wxSizeEvent *result = 0 ;
23828 wxSize temp1 ;
23829 int val2 ;
23830 int ecode2 = 0 ;
23831 PyObject * obj0 = 0 ;
23832 PyObject * obj1 = 0 ;
23833 char * kwnames[] = {
23834 (char *) "sz",(char *) "winid", NULL
23835 };
23836
23837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23838 if (obj0) {
23839 {
23840 arg1 = &temp1;
23841 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23842 }
23843 }
23844 if (obj1) {
23845 ecode2 = SWIG_AsVal_int(obj1, &val2);
23846 if (!SWIG_IsOK(ecode2)) {
23847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23848 }
23849 arg2 = static_cast< int >(val2);
23850 }
23851 {
23852 PyThreadState* __tstate = wxPyBeginAllowThreads();
23853 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23854 wxPyEndAllowThreads(__tstate);
23855 if (PyErr_Occurred()) SWIG_fail;
23856 }
23857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23858 return resultobj;
23859 fail:
23860 return NULL;
23861 }
23862
23863
23864 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23865 PyObject *resultobj = 0;
23866 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23867 wxSize result;
23868 void *argp1 = 0 ;
23869 int res1 = 0 ;
23870 PyObject *swig_obj[1] ;
23871
23872 if (!args) SWIG_fail;
23873 swig_obj[0] = args;
23874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23875 if (!SWIG_IsOK(res1)) {
23876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23877 }
23878 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23879 {
23880 PyThreadState* __tstate = wxPyBeginAllowThreads();
23881 result = ((wxSizeEvent const *)arg1)->GetSize();
23882 wxPyEndAllowThreads(__tstate);
23883 if (PyErr_Occurred()) SWIG_fail;
23884 }
23885 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23886 return resultobj;
23887 fail:
23888 return NULL;
23889 }
23890
23891
23892 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23893 PyObject *resultobj = 0;
23894 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23895 wxRect result;
23896 void *argp1 = 0 ;
23897 int res1 = 0 ;
23898 PyObject *swig_obj[1] ;
23899
23900 if (!args) SWIG_fail;
23901 swig_obj[0] = args;
23902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23903 if (!SWIG_IsOK(res1)) {
23904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23905 }
23906 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23907 {
23908 PyThreadState* __tstate = wxPyBeginAllowThreads();
23909 result = ((wxSizeEvent const *)arg1)->GetRect();
23910 wxPyEndAllowThreads(__tstate);
23911 if (PyErr_Occurred()) SWIG_fail;
23912 }
23913 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23914 return resultobj;
23915 fail:
23916 return NULL;
23917 }
23918
23919
23920 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23921 PyObject *resultobj = 0;
23922 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23923 wxRect arg2 ;
23924 void *argp1 = 0 ;
23925 int res1 = 0 ;
23926 void *argp2 ;
23927 int res2 = 0 ;
23928 PyObject * obj0 = 0 ;
23929 PyObject * obj1 = 0 ;
23930 char * kwnames[] = {
23931 (char *) "self",(char *) "rect", NULL
23932 };
23933
23934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23936 if (!SWIG_IsOK(res1)) {
23937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23938 }
23939 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23940 {
23941 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23942 if (!SWIG_IsOK(res2)) {
23943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23944 }
23945 if (!argp2) {
23946 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23947 } else {
23948 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23949 arg2 = *temp;
23950 if (SWIG_IsNewObj(res2)) delete temp;
23951 }
23952 }
23953 {
23954 PyThreadState* __tstate = wxPyBeginAllowThreads();
23955 (arg1)->SetRect(arg2);
23956 wxPyEndAllowThreads(__tstate);
23957 if (PyErr_Occurred()) SWIG_fail;
23958 }
23959 resultobj = SWIG_Py_Void();
23960 return resultobj;
23961 fail:
23962 return NULL;
23963 }
23964
23965
23966 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23967 PyObject *resultobj = 0;
23968 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23969 wxSize arg2 ;
23970 void *argp1 = 0 ;
23971 int res1 = 0 ;
23972 void *argp2 ;
23973 int res2 = 0 ;
23974 PyObject * obj0 = 0 ;
23975 PyObject * obj1 = 0 ;
23976 char * kwnames[] = {
23977 (char *) "self",(char *) "size", NULL
23978 };
23979
23980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23982 if (!SWIG_IsOK(res1)) {
23983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23984 }
23985 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23986 {
23987 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23988 if (!SWIG_IsOK(res2)) {
23989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23990 }
23991 if (!argp2) {
23992 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23993 } else {
23994 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23995 arg2 = *temp;
23996 if (SWIG_IsNewObj(res2)) delete temp;
23997 }
23998 }
23999 {
24000 PyThreadState* __tstate = wxPyBeginAllowThreads();
24001 wxSizeEvent_SetSize(arg1,arg2);
24002 wxPyEndAllowThreads(__tstate);
24003 if (PyErr_Occurred()) SWIG_fail;
24004 }
24005 resultobj = SWIG_Py_Void();
24006 return resultobj;
24007 fail:
24008 return NULL;
24009 }
24010
24011
24012 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24013 PyObject *resultobj = 0;
24014 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24015 wxSize *arg2 = (wxSize *) 0 ;
24016 void *argp1 = 0 ;
24017 int res1 = 0 ;
24018 void *argp2 = 0 ;
24019 int res2 = 0 ;
24020 PyObject *swig_obj[2] ;
24021
24022 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
24023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24024 if (!SWIG_IsOK(res1)) {
24025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24026 }
24027 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24028 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
24029 if (!SWIG_IsOK(res2)) {
24030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
24031 }
24032 arg2 = reinterpret_cast< wxSize * >(argp2);
24033 if (arg1) (arg1)->m_size = *arg2;
24034
24035 resultobj = SWIG_Py_Void();
24036 return resultobj;
24037 fail:
24038 return NULL;
24039 }
24040
24041
24042 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24043 PyObject *resultobj = 0;
24044 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24045 wxSize *result = 0 ;
24046 void *argp1 = 0 ;
24047 int res1 = 0 ;
24048 PyObject *swig_obj[1] ;
24049
24050 if (!args) SWIG_fail;
24051 swig_obj[0] = args;
24052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24053 if (!SWIG_IsOK(res1)) {
24054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24055 }
24056 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24057 result = (wxSize *)& ((arg1)->m_size);
24058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
24059 return resultobj;
24060 fail:
24061 return NULL;
24062 }
24063
24064
24065 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24066 PyObject *resultobj = 0;
24067 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24068 wxRect *arg2 = (wxRect *) 0 ;
24069 void *argp1 = 0 ;
24070 int res1 = 0 ;
24071 void *argp2 = 0 ;
24072 int res2 = 0 ;
24073 PyObject *swig_obj[2] ;
24074
24075 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
24076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24077 if (!SWIG_IsOK(res1)) {
24078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24079 }
24080 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24081 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
24082 if (!SWIG_IsOK(res2)) {
24083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
24084 }
24085 arg2 = reinterpret_cast< wxRect * >(argp2);
24086 if (arg1) (arg1)->m_rect = *arg2;
24087
24088 resultobj = SWIG_Py_Void();
24089 return resultobj;
24090 fail:
24091 return NULL;
24092 }
24093
24094
24095 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24096 PyObject *resultobj = 0;
24097 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24098 wxRect *result = 0 ;
24099 void *argp1 = 0 ;
24100 int res1 = 0 ;
24101 PyObject *swig_obj[1] ;
24102
24103 if (!args) SWIG_fail;
24104 swig_obj[0] = args;
24105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24106 if (!SWIG_IsOK(res1)) {
24107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24108 }
24109 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24110 result = (wxRect *)& ((arg1)->m_rect);
24111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
24112 return resultobj;
24113 fail:
24114 return NULL;
24115 }
24116
24117
24118 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24119 PyObject *obj;
24120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24121 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
24122 return SWIG_Py_Void();
24123 }
24124
24125 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24126 return SWIG_Python_InitShadowInstance(args);
24127 }
24128
24129 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24130 PyObject *resultobj = 0;
24131 wxPoint const &arg1_defvalue = wxDefaultPosition ;
24132 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
24133 int arg2 = (int) 0 ;
24134 wxMoveEvent *result = 0 ;
24135 wxPoint temp1 ;
24136 int val2 ;
24137 int ecode2 = 0 ;
24138 PyObject * obj0 = 0 ;
24139 PyObject * obj1 = 0 ;
24140 char * kwnames[] = {
24141 (char *) "pos",(char *) "winid", NULL
24142 };
24143
24144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24145 if (obj0) {
24146 {
24147 arg1 = &temp1;
24148 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
24149 }
24150 }
24151 if (obj1) {
24152 ecode2 = SWIG_AsVal_int(obj1, &val2);
24153 if (!SWIG_IsOK(ecode2)) {
24154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
24155 }
24156 arg2 = static_cast< int >(val2);
24157 }
24158 {
24159 PyThreadState* __tstate = wxPyBeginAllowThreads();
24160 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
24161 wxPyEndAllowThreads(__tstate);
24162 if (PyErr_Occurred()) SWIG_fail;
24163 }
24164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
24165 return resultobj;
24166 fail:
24167 return NULL;
24168 }
24169
24170
24171 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24172 PyObject *resultobj = 0;
24173 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24174 wxPoint result;
24175 void *argp1 = 0 ;
24176 int res1 = 0 ;
24177 PyObject *swig_obj[1] ;
24178
24179 if (!args) SWIG_fail;
24180 swig_obj[0] = args;
24181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24182 if (!SWIG_IsOK(res1)) {
24183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24184 }
24185 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24186 {
24187 PyThreadState* __tstate = wxPyBeginAllowThreads();
24188 result = ((wxMoveEvent const *)arg1)->GetPosition();
24189 wxPyEndAllowThreads(__tstate);
24190 if (PyErr_Occurred()) SWIG_fail;
24191 }
24192 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24193 return resultobj;
24194 fail:
24195 return NULL;
24196 }
24197
24198
24199 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24200 PyObject *resultobj = 0;
24201 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24202 wxRect result;
24203 void *argp1 = 0 ;
24204 int res1 = 0 ;
24205 PyObject *swig_obj[1] ;
24206
24207 if (!args) SWIG_fail;
24208 swig_obj[0] = args;
24209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24210 if (!SWIG_IsOK(res1)) {
24211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24212 }
24213 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24214 {
24215 PyThreadState* __tstate = wxPyBeginAllowThreads();
24216 result = ((wxMoveEvent const *)arg1)->GetRect();
24217 wxPyEndAllowThreads(__tstate);
24218 if (PyErr_Occurred()) SWIG_fail;
24219 }
24220 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
24221 return resultobj;
24222 fail:
24223 return NULL;
24224 }
24225
24226
24227 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24228 PyObject *resultobj = 0;
24229 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24230 wxRect *arg2 = 0 ;
24231 void *argp1 = 0 ;
24232 int res1 = 0 ;
24233 wxRect temp2 ;
24234 PyObject * obj0 = 0 ;
24235 PyObject * obj1 = 0 ;
24236 char * kwnames[] = {
24237 (char *) "self",(char *) "rect", NULL
24238 };
24239
24240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
24241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24242 if (!SWIG_IsOK(res1)) {
24243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24244 }
24245 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24246 {
24247 arg2 = &temp2;
24248 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
24249 }
24250 {
24251 PyThreadState* __tstate = wxPyBeginAllowThreads();
24252 (arg1)->SetRect((wxRect const &)*arg2);
24253 wxPyEndAllowThreads(__tstate);
24254 if (PyErr_Occurred()) SWIG_fail;
24255 }
24256 resultobj = SWIG_Py_Void();
24257 return resultobj;
24258 fail:
24259 return NULL;
24260 }
24261
24262
24263 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24264 PyObject *resultobj = 0;
24265 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24266 wxPoint *arg2 = 0 ;
24267 void *argp1 = 0 ;
24268 int res1 = 0 ;
24269 wxPoint temp2 ;
24270 PyObject * obj0 = 0 ;
24271 PyObject * obj1 = 0 ;
24272 char * kwnames[] = {
24273 (char *) "self",(char *) "pos", NULL
24274 };
24275
24276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24278 if (!SWIG_IsOK(res1)) {
24279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24280 }
24281 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24282 {
24283 arg2 = &temp2;
24284 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
24285 }
24286 {
24287 PyThreadState* __tstate = wxPyBeginAllowThreads();
24288 (arg1)->SetPosition((wxPoint const &)*arg2);
24289 wxPyEndAllowThreads(__tstate);
24290 if (PyErr_Occurred()) SWIG_fail;
24291 }
24292 resultobj = SWIG_Py_Void();
24293 return resultobj;
24294 fail:
24295 return NULL;
24296 }
24297
24298
24299 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24300 PyObject *obj;
24301 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24302 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
24303 return SWIG_Py_Void();
24304 }
24305
24306 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24307 return SWIG_Python_InitShadowInstance(args);
24308 }
24309
24310 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24311 PyObject *resultobj = 0;
24312 int arg1 = (int) 0 ;
24313 wxPaintEvent *result = 0 ;
24314 int val1 ;
24315 int ecode1 = 0 ;
24316 PyObject * obj0 = 0 ;
24317 char * kwnames[] = {
24318 (char *) "Id", NULL
24319 };
24320
24321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
24322 if (obj0) {
24323 ecode1 = SWIG_AsVal_int(obj0, &val1);
24324 if (!SWIG_IsOK(ecode1)) {
24325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
24326 }
24327 arg1 = static_cast< int >(val1);
24328 }
24329 {
24330 PyThreadState* __tstate = wxPyBeginAllowThreads();
24331 result = (wxPaintEvent *)new wxPaintEvent(arg1);
24332 wxPyEndAllowThreads(__tstate);
24333 if (PyErr_Occurred()) SWIG_fail;
24334 }
24335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
24336 return resultobj;
24337 fail:
24338 return NULL;
24339 }
24340
24341
24342 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24343 PyObject *obj;
24344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24345 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
24346 return SWIG_Py_Void();
24347 }
24348
24349 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24350 return SWIG_Python_InitShadowInstance(args);
24351 }
24352
24353 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24354 PyObject *resultobj = 0;
24355 int arg1 = (int) 0 ;
24356 wxNcPaintEvent *result = 0 ;
24357 int val1 ;
24358 int ecode1 = 0 ;
24359 PyObject * obj0 = 0 ;
24360 char * kwnames[] = {
24361 (char *) "winid", NULL
24362 };
24363
24364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
24365 if (obj0) {
24366 ecode1 = SWIG_AsVal_int(obj0, &val1);
24367 if (!SWIG_IsOK(ecode1)) {
24368 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
24369 }
24370 arg1 = static_cast< int >(val1);
24371 }
24372 {
24373 PyThreadState* __tstate = wxPyBeginAllowThreads();
24374 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
24375 wxPyEndAllowThreads(__tstate);
24376 if (PyErr_Occurred()) SWIG_fail;
24377 }
24378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
24379 return resultobj;
24380 fail:
24381 return NULL;
24382 }
24383
24384
24385 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24386 PyObject *obj;
24387 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24388 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
24389 return SWIG_Py_Void();
24390 }
24391
24392 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24393 return SWIG_Python_InitShadowInstance(args);
24394 }
24395
24396 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24397 PyObject *resultobj = 0;
24398 int arg1 = (int) 0 ;
24399 wxDC *arg2 = (wxDC *) NULL ;
24400 wxEraseEvent *result = 0 ;
24401 int val1 ;
24402 int ecode1 = 0 ;
24403 void *argp2 = 0 ;
24404 int res2 = 0 ;
24405 PyObject * obj0 = 0 ;
24406 PyObject * obj1 = 0 ;
24407 char * kwnames[] = {
24408 (char *) "Id",(char *) "dc", NULL
24409 };
24410
24411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24412 if (obj0) {
24413 ecode1 = SWIG_AsVal_int(obj0, &val1);
24414 if (!SWIG_IsOK(ecode1)) {
24415 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
24416 }
24417 arg1 = static_cast< int >(val1);
24418 }
24419 if (obj1) {
24420 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
24421 if (!SWIG_IsOK(res2)) {
24422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
24423 }
24424 arg2 = reinterpret_cast< wxDC * >(argp2);
24425 }
24426 {
24427 PyThreadState* __tstate = wxPyBeginAllowThreads();
24428 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
24429 wxPyEndAllowThreads(__tstate);
24430 if (PyErr_Occurred()) SWIG_fail;
24431 }
24432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
24433 return resultobj;
24434 fail:
24435 return NULL;
24436 }
24437
24438
24439 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24440 PyObject *resultobj = 0;
24441 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
24442 wxDC *result = 0 ;
24443 void *argp1 = 0 ;
24444 int res1 = 0 ;
24445 PyObject *swig_obj[1] ;
24446
24447 if (!args) SWIG_fail;
24448 swig_obj[0] = args;
24449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
24450 if (!SWIG_IsOK(res1)) {
24451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
24452 }
24453 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
24454 {
24455 PyThreadState* __tstate = wxPyBeginAllowThreads();
24456 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
24457 wxPyEndAllowThreads(__tstate);
24458 if (PyErr_Occurred()) SWIG_fail;
24459 }
24460 {
24461 resultobj = wxPyMake_wxObject(result, (bool)0);
24462 }
24463 return resultobj;
24464 fail:
24465 return NULL;
24466 }
24467
24468
24469 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24470 PyObject *obj;
24471 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24472 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
24473 return SWIG_Py_Void();
24474 }
24475
24476 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24477 return SWIG_Python_InitShadowInstance(args);
24478 }
24479
24480 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24481 PyObject *resultobj = 0;
24482 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24483 int arg2 = (int) 0 ;
24484 wxFocusEvent *result = 0 ;
24485 int val1 ;
24486 int ecode1 = 0 ;
24487 int val2 ;
24488 int ecode2 = 0 ;
24489 PyObject * obj0 = 0 ;
24490 PyObject * obj1 = 0 ;
24491 char * kwnames[] = {
24492 (char *) "type",(char *) "winid", NULL
24493 };
24494
24495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24496 if (obj0) {
24497 ecode1 = SWIG_AsVal_int(obj0, &val1);
24498 if (!SWIG_IsOK(ecode1)) {
24499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24500 }
24501 arg1 = static_cast< wxEventType >(val1);
24502 }
24503 if (obj1) {
24504 ecode2 = SWIG_AsVal_int(obj1, &val2);
24505 if (!SWIG_IsOK(ecode2)) {
24506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
24507 }
24508 arg2 = static_cast< int >(val2);
24509 }
24510 {
24511 PyThreadState* __tstate = wxPyBeginAllowThreads();
24512 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
24513 wxPyEndAllowThreads(__tstate);
24514 if (PyErr_Occurred()) SWIG_fail;
24515 }
24516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
24517 return resultobj;
24518 fail:
24519 return NULL;
24520 }
24521
24522
24523 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24524 PyObject *resultobj = 0;
24525 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24526 wxWindow *result = 0 ;
24527 void *argp1 = 0 ;
24528 int res1 = 0 ;
24529 PyObject *swig_obj[1] ;
24530
24531 if (!args) SWIG_fail;
24532 swig_obj[0] = args;
24533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24534 if (!SWIG_IsOK(res1)) {
24535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
24536 }
24537 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24538 {
24539 PyThreadState* __tstate = wxPyBeginAllowThreads();
24540 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
24541 wxPyEndAllowThreads(__tstate);
24542 if (PyErr_Occurred()) SWIG_fail;
24543 }
24544 {
24545 resultobj = wxPyMake_wxObject(result, (bool)0);
24546 }
24547 return resultobj;
24548 fail:
24549 return NULL;
24550 }
24551
24552
24553 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24554 PyObject *resultobj = 0;
24555 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24556 wxWindow *arg2 = (wxWindow *) 0 ;
24557 void *argp1 = 0 ;
24558 int res1 = 0 ;
24559 void *argp2 = 0 ;
24560 int res2 = 0 ;
24561 PyObject * obj0 = 0 ;
24562 PyObject * obj1 = 0 ;
24563 char * kwnames[] = {
24564 (char *) "self",(char *) "win", NULL
24565 };
24566
24567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
24568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24569 if (!SWIG_IsOK(res1)) {
24570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
24571 }
24572 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24573 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24574 if (!SWIG_IsOK(res2)) {
24575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
24576 }
24577 arg2 = reinterpret_cast< wxWindow * >(argp2);
24578 {
24579 PyThreadState* __tstate = wxPyBeginAllowThreads();
24580 (arg1)->SetWindow(arg2);
24581 wxPyEndAllowThreads(__tstate);
24582 if (PyErr_Occurred()) SWIG_fail;
24583 }
24584 resultobj = SWIG_Py_Void();
24585 return resultobj;
24586 fail:
24587 return NULL;
24588 }
24589
24590
24591 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24592 PyObject *obj;
24593 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24594 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24595 return SWIG_Py_Void();
24596 }
24597
24598 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24599 return SWIG_Python_InitShadowInstance(args);
24600 }
24601
24602 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24603 PyObject *resultobj = 0;
24604 wxWindow *arg1 = (wxWindow *) NULL ;
24605 wxChildFocusEvent *result = 0 ;
24606 void *argp1 = 0 ;
24607 int res1 = 0 ;
24608 PyObject * obj0 = 0 ;
24609 char * kwnames[] = {
24610 (char *) "win", NULL
24611 };
24612
24613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24614 if (obj0) {
24615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24616 if (!SWIG_IsOK(res1)) {
24617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24618 }
24619 arg1 = reinterpret_cast< wxWindow * >(argp1);
24620 }
24621 {
24622 PyThreadState* __tstate = wxPyBeginAllowThreads();
24623 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24624 wxPyEndAllowThreads(__tstate);
24625 if (PyErr_Occurred()) SWIG_fail;
24626 }
24627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24628 return resultobj;
24629 fail:
24630 return NULL;
24631 }
24632
24633
24634 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24635 PyObject *resultobj = 0;
24636 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24637 wxWindow *result = 0 ;
24638 void *argp1 = 0 ;
24639 int res1 = 0 ;
24640 PyObject *swig_obj[1] ;
24641
24642 if (!args) SWIG_fail;
24643 swig_obj[0] = args;
24644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24645 if (!SWIG_IsOK(res1)) {
24646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24647 }
24648 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24649 {
24650 PyThreadState* __tstate = wxPyBeginAllowThreads();
24651 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24652 wxPyEndAllowThreads(__tstate);
24653 if (PyErr_Occurred()) SWIG_fail;
24654 }
24655 {
24656 resultobj = wxPyMake_wxObject(result, (bool)0);
24657 }
24658 return resultobj;
24659 fail:
24660 return NULL;
24661 }
24662
24663
24664 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24665 PyObject *obj;
24666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24667 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24668 return SWIG_Py_Void();
24669 }
24670
24671 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24672 return SWIG_Python_InitShadowInstance(args);
24673 }
24674
24675 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24676 PyObject *resultobj = 0;
24677 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24678 bool arg2 = (bool) true ;
24679 int arg3 = (int) 0 ;
24680 wxActivateEvent *result = 0 ;
24681 int val1 ;
24682 int ecode1 = 0 ;
24683 bool val2 ;
24684 int ecode2 = 0 ;
24685 int val3 ;
24686 int ecode3 = 0 ;
24687 PyObject * obj0 = 0 ;
24688 PyObject * obj1 = 0 ;
24689 PyObject * obj2 = 0 ;
24690 char * kwnames[] = {
24691 (char *) "type",(char *) "active",(char *) "Id", NULL
24692 };
24693
24694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24695 if (obj0) {
24696 ecode1 = SWIG_AsVal_int(obj0, &val1);
24697 if (!SWIG_IsOK(ecode1)) {
24698 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24699 }
24700 arg1 = static_cast< wxEventType >(val1);
24701 }
24702 if (obj1) {
24703 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24704 if (!SWIG_IsOK(ecode2)) {
24705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24706 }
24707 arg2 = static_cast< bool >(val2);
24708 }
24709 if (obj2) {
24710 ecode3 = SWIG_AsVal_int(obj2, &val3);
24711 if (!SWIG_IsOK(ecode3)) {
24712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24713 }
24714 arg3 = static_cast< int >(val3);
24715 }
24716 {
24717 PyThreadState* __tstate = wxPyBeginAllowThreads();
24718 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24719 wxPyEndAllowThreads(__tstate);
24720 if (PyErr_Occurred()) SWIG_fail;
24721 }
24722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24723 return resultobj;
24724 fail:
24725 return NULL;
24726 }
24727
24728
24729 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24730 PyObject *resultobj = 0;
24731 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24732 bool result;
24733 void *argp1 = 0 ;
24734 int res1 = 0 ;
24735 PyObject *swig_obj[1] ;
24736
24737 if (!args) SWIG_fail;
24738 swig_obj[0] = args;
24739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24740 if (!SWIG_IsOK(res1)) {
24741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24742 }
24743 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24744 {
24745 PyThreadState* __tstate = wxPyBeginAllowThreads();
24746 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24747 wxPyEndAllowThreads(__tstate);
24748 if (PyErr_Occurred()) SWIG_fail;
24749 }
24750 {
24751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24752 }
24753 return resultobj;
24754 fail:
24755 return NULL;
24756 }
24757
24758
24759 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24760 PyObject *obj;
24761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24762 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24763 return SWIG_Py_Void();
24764 }
24765
24766 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24767 return SWIG_Python_InitShadowInstance(args);
24768 }
24769
24770 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24771 PyObject *resultobj = 0;
24772 int arg1 = (int) 0 ;
24773 wxInitDialogEvent *result = 0 ;
24774 int val1 ;
24775 int ecode1 = 0 ;
24776 PyObject * obj0 = 0 ;
24777 char * kwnames[] = {
24778 (char *) "Id", NULL
24779 };
24780
24781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24782 if (obj0) {
24783 ecode1 = SWIG_AsVal_int(obj0, &val1);
24784 if (!SWIG_IsOK(ecode1)) {
24785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24786 }
24787 arg1 = static_cast< int >(val1);
24788 }
24789 {
24790 PyThreadState* __tstate = wxPyBeginAllowThreads();
24791 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24792 wxPyEndAllowThreads(__tstate);
24793 if (PyErr_Occurred()) SWIG_fail;
24794 }
24795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24796 return resultobj;
24797 fail:
24798 return NULL;
24799 }
24800
24801
24802 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24803 PyObject *obj;
24804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24805 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24806 return SWIG_Py_Void();
24807 }
24808
24809 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24810 return SWIG_Python_InitShadowInstance(args);
24811 }
24812
24813 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24814 PyObject *resultobj = 0;
24815 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24816 int arg2 = (int) 0 ;
24817 wxMenu *arg3 = (wxMenu *) NULL ;
24818 wxMenuEvent *result = 0 ;
24819 int val1 ;
24820 int ecode1 = 0 ;
24821 int val2 ;
24822 int ecode2 = 0 ;
24823 void *argp3 = 0 ;
24824 int res3 = 0 ;
24825 PyObject * obj0 = 0 ;
24826 PyObject * obj1 = 0 ;
24827 PyObject * obj2 = 0 ;
24828 char * kwnames[] = {
24829 (char *) "type",(char *) "winid",(char *) "menu", NULL
24830 };
24831
24832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24833 if (obj0) {
24834 ecode1 = SWIG_AsVal_int(obj0, &val1);
24835 if (!SWIG_IsOK(ecode1)) {
24836 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24837 }
24838 arg1 = static_cast< wxEventType >(val1);
24839 }
24840 if (obj1) {
24841 ecode2 = SWIG_AsVal_int(obj1, &val2);
24842 if (!SWIG_IsOK(ecode2)) {
24843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24844 }
24845 arg2 = static_cast< int >(val2);
24846 }
24847 if (obj2) {
24848 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24849 if (!SWIG_IsOK(res3)) {
24850 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24851 }
24852 arg3 = reinterpret_cast< wxMenu * >(argp3);
24853 }
24854 {
24855 PyThreadState* __tstate = wxPyBeginAllowThreads();
24856 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24857 wxPyEndAllowThreads(__tstate);
24858 if (PyErr_Occurred()) SWIG_fail;
24859 }
24860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24861 return resultobj;
24862 fail:
24863 return NULL;
24864 }
24865
24866
24867 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24868 PyObject *resultobj = 0;
24869 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24870 int result;
24871 void *argp1 = 0 ;
24872 int res1 = 0 ;
24873 PyObject *swig_obj[1] ;
24874
24875 if (!args) SWIG_fail;
24876 swig_obj[0] = args;
24877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24878 if (!SWIG_IsOK(res1)) {
24879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24880 }
24881 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24882 {
24883 PyThreadState* __tstate = wxPyBeginAllowThreads();
24884 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24885 wxPyEndAllowThreads(__tstate);
24886 if (PyErr_Occurred()) SWIG_fail;
24887 }
24888 resultobj = SWIG_From_int(static_cast< int >(result));
24889 return resultobj;
24890 fail:
24891 return NULL;
24892 }
24893
24894
24895 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24896 PyObject *resultobj = 0;
24897 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24898 bool result;
24899 void *argp1 = 0 ;
24900 int res1 = 0 ;
24901 PyObject *swig_obj[1] ;
24902
24903 if (!args) SWIG_fail;
24904 swig_obj[0] = args;
24905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24906 if (!SWIG_IsOK(res1)) {
24907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24908 }
24909 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24910 {
24911 PyThreadState* __tstate = wxPyBeginAllowThreads();
24912 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24913 wxPyEndAllowThreads(__tstate);
24914 if (PyErr_Occurred()) SWIG_fail;
24915 }
24916 {
24917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24918 }
24919 return resultobj;
24920 fail:
24921 return NULL;
24922 }
24923
24924
24925 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24926 PyObject *resultobj = 0;
24927 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24928 wxMenu *result = 0 ;
24929 void *argp1 = 0 ;
24930 int res1 = 0 ;
24931 PyObject *swig_obj[1] ;
24932
24933 if (!args) SWIG_fail;
24934 swig_obj[0] = args;
24935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24936 if (!SWIG_IsOK(res1)) {
24937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24938 }
24939 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24940 {
24941 PyThreadState* __tstate = wxPyBeginAllowThreads();
24942 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24943 wxPyEndAllowThreads(__tstate);
24944 if (PyErr_Occurred()) SWIG_fail;
24945 }
24946 {
24947 resultobj = wxPyMake_wxObject(result, (bool)0);
24948 }
24949 return resultobj;
24950 fail:
24951 return NULL;
24952 }
24953
24954
24955 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24956 PyObject *obj;
24957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24958 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24959 return SWIG_Py_Void();
24960 }
24961
24962 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24963 return SWIG_Python_InitShadowInstance(args);
24964 }
24965
24966 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24967 PyObject *resultobj = 0;
24968 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24969 int arg2 = (int) 0 ;
24970 wxCloseEvent *result = 0 ;
24971 int val1 ;
24972 int ecode1 = 0 ;
24973 int val2 ;
24974 int ecode2 = 0 ;
24975 PyObject * obj0 = 0 ;
24976 PyObject * obj1 = 0 ;
24977 char * kwnames[] = {
24978 (char *) "type",(char *) "winid", NULL
24979 };
24980
24981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24982 if (obj0) {
24983 ecode1 = SWIG_AsVal_int(obj0, &val1);
24984 if (!SWIG_IsOK(ecode1)) {
24985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24986 }
24987 arg1 = static_cast< wxEventType >(val1);
24988 }
24989 if (obj1) {
24990 ecode2 = SWIG_AsVal_int(obj1, &val2);
24991 if (!SWIG_IsOK(ecode2)) {
24992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24993 }
24994 arg2 = static_cast< int >(val2);
24995 }
24996 {
24997 PyThreadState* __tstate = wxPyBeginAllowThreads();
24998 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24999 wxPyEndAllowThreads(__tstate);
25000 if (PyErr_Occurred()) SWIG_fail;
25001 }
25002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
25003 return resultobj;
25004 fail:
25005 return NULL;
25006 }
25007
25008
25009 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25010 PyObject *resultobj = 0;
25011 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25012 bool arg2 ;
25013 void *argp1 = 0 ;
25014 int res1 = 0 ;
25015 bool val2 ;
25016 int ecode2 = 0 ;
25017 PyObject * obj0 = 0 ;
25018 PyObject * obj1 = 0 ;
25019 char * kwnames[] = {
25020 (char *) "self",(char *) "logOff", NULL
25021 };
25022
25023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
25024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25025 if (!SWIG_IsOK(res1)) {
25026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25027 }
25028 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25029 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25030 if (!SWIG_IsOK(ecode2)) {
25031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
25032 }
25033 arg2 = static_cast< bool >(val2);
25034 {
25035 PyThreadState* __tstate = wxPyBeginAllowThreads();
25036 (arg1)->SetLoggingOff(arg2);
25037 wxPyEndAllowThreads(__tstate);
25038 if (PyErr_Occurred()) SWIG_fail;
25039 }
25040 resultobj = SWIG_Py_Void();
25041 return resultobj;
25042 fail:
25043 return NULL;
25044 }
25045
25046
25047 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25048 PyObject *resultobj = 0;
25049 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25050 bool result;
25051 void *argp1 = 0 ;
25052 int res1 = 0 ;
25053 PyObject *swig_obj[1] ;
25054
25055 if (!args) SWIG_fail;
25056 swig_obj[0] = args;
25057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25058 if (!SWIG_IsOK(res1)) {
25059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25060 }
25061 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25062 {
25063 PyThreadState* __tstate = wxPyBeginAllowThreads();
25064 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
25065 wxPyEndAllowThreads(__tstate);
25066 if (PyErr_Occurred()) SWIG_fail;
25067 }
25068 {
25069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25070 }
25071 return resultobj;
25072 fail:
25073 return NULL;
25074 }
25075
25076
25077 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25078 PyObject *resultobj = 0;
25079 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25080 bool arg2 = (bool) true ;
25081 void *argp1 = 0 ;
25082 int res1 = 0 ;
25083 bool val2 ;
25084 int ecode2 = 0 ;
25085 PyObject * obj0 = 0 ;
25086 PyObject * obj1 = 0 ;
25087 char * kwnames[] = {
25088 (char *) "self",(char *) "veto", NULL
25089 };
25090
25091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
25092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25093 if (!SWIG_IsOK(res1)) {
25094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25095 }
25096 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25097 if (obj1) {
25098 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25099 if (!SWIG_IsOK(ecode2)) {
25100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
25101 }
25102 arg2 = static_cast< bool >(val2);
25103 }
25104 {
25105 PyThreadState* __tstate = wxPyBeginAllowThreads();
25106 (arg1)->Veto(arg2);
25107 wxPyEndAllowThreads(__tstate);
25108 if (PyErr_Occurred()) SWIG_fail;
25109 }
25110 resultobj = SWIG_Py_Void();
25111 return resultobj;
25112 fail:
25113 return NULL;
25114 }
25115
25116
25117 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25118 PyObject *resultobj = 0;
25119 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25120 bool result;
25121 void *argp1 = 0 ;
25122 int res1 = 0 ;
25123 PyObject *swig_obj[1] ;
25124
25125 if (!args) SWIG_fail;
25126 swig_obj[0] = args;
25127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25128 if (!SWIG_IsOK(res1)) {
25129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25130 }
25131 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25132 {
25133 PyThreadState* __tstate = wxPyBeginAllowThreads();
25134 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
25135 wxPyEndAllowThreads(__tstate);
25136 if (PyErr_Occurred()) SWIG_fail;
25137 }
25138 {
25139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25140 }
25141 return resultobj;
25142 fail:
25143 return NULL;
25144 }
25145
25146
25147 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25148 PyObject *resultobj = 0;
25149 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25150 bool arg2 ;
25151 void *argp1 = 0 ;
25152 int res1 = 0 ;
25153 bool val2 ;
25154 int ecode2 = 0 ;
25155 PyObject * obj0 = 0 ;
25156 PyObject * obj1 = 0 ;
25157 char * kwnames[] = {
25158 (char *) "self",(char *) "canVeto", NULL
25159 };
25160
25161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
25162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25163 if (!SWIG_IsOK(res1)) {
25164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25165 }
25166 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25167 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25168 if (!SWIG_IsOK(ecode2)) {
25169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
25170 }
25171 arg2 = static_cast< bool >(val2);
25172 {
25173 PyThreadState* __tstate = wxPyBeginAllowThreads();
25174 (arg1)->SetCanVeto(arg2);
25175 wxPyEndAllowThreads(__tstate);
25176 if (PyErr_Occurred()) SWIG_fail;
25177 }
25178 resultobj = SWIG_Py_Void();
25179 return resultobj;
25180 fail:
25181 return NULL;
25182 }
25183
25184
25185 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25186 PyObject *resultobj = 0;
25187 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25188 bool result;
25189 void *argp1 = 0 ;
25190 int res1 = 0 ;
25191 PyObject *swig_obj[1] ;
25192
25193 if (!args) SWIG_fail;
25194 swig_obj[0] = args;
25195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25196 if (!SWIG_IsOK(res1)) {
25197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25198 }
25199 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25200 {
25201 PyThreadState* __tstate = wxPyBeginAllowThreads();
25202 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
25203 wxPyEndAllowThreads(__tstate);
25204 if (PyErr_Occurred()) SWIG_fail;
25205 }
25206 {
25207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25208 }
25209 return resultobj;
25210 fail:
25211 return NULL;
25212 }
25213
25214
25215 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25216 PyObject *obj;
25217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25218 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
25219 return SWIG_Py_Void();
25220 }
25221
25222 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25223 return SWIG_Python_InitShadowInstance(args);
25224 }
25225
25226 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25227 PyObject *resultobj = 0;
25228 int arg1 = (int) 0 ;
25229 bool arg2 = (bool) false ;
25230 wxShowEvent *result = 0 ;
25231 int val1 ;
25232 int ecode1 = 0 ;
25233 bool val2 ;
25234 int ecode2 = 0 ;
25235 PyObject * obj0 = 0 ;
25236 PyObject * obj1 = 0 ;
25237 char * kwnames[] = {
25238 (char *) "winid",(char *) "show", NULL
25239 };
25240
25241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25242 if (obj0) {
25243 ecode1 = SWIG_AsVal_int(obj0, &val1);
25244 if (!SWIG_IsOK(ecode1)) {
25245 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
25246 }
25247 arg1 = static_cast< int >(val1);
25248 }
25249 if (obj1) {
25250 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25251 if (!SWIG_IsOK(ecode2)) {
25252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
25253 }
25254 arg2 = static_cast< bool >(val2);
25255 }
25256 {
25257 PyThreadState* __tstate = wxPyBeginAllowThreads();
25258 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
25259 wxPyEndAllowThreads(__tstate);
25260 if (PyErr_Occurred()) SWIG_fail;
25261 }
25262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
25263 return resultobj;
25264 fail:
25265 return NULL;
25266 }
25267
25268
25269 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25270 PyObject *resultobj = 0;
25271 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25272 bool arg2 ;
25273 void *argp1 = 0 ;
25274 int res1 = 0 ;
25275 bool val2 ;
25276 int ecode2 = 0 ;
25277 PyObject * obj0 = 0 ;
25278 PyObject * obj1 = 0 ;
25279 char * kwnames[] = {
25280 (char *) "self",(char *) "show", NULL
25281 };
25282
25283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
25284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25285 if (!SWIG_IsOK(res1)) {
25286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
25287 }
25288 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25289 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25290 if (!SWIG_IsOK(ecode2)) {
25291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
25292 }
25293 arg2 = static_cast< bool >(val2);
25294 {
25295 PyThreadState* __tstate = wxPyBeginAllowThreads();
25296 (arg1)->SetShow(arg2);
25297 wxPyEndAllowThreads(__tstate);
25298 if (PyErr_Occurred()) SWIG_fail;
25299 }
25300 resultobj = SWIG_Py_Void();
25301 return resultobj;
25302 fail:
25303 return NULL;
25304 }
25305
25306
25307 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25308 PyObject *resultobj = 0;
25309 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25310 bool result;
25311 void *argp1 = 0 ;
25312 int res1 = 0 ;
25313 PyObject *swig_obj[1] ;
25314
25315 if (!args) SWIG_fail;
25316 swig_obj[0] = args;
25317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25318 if (!SWIG_IsOK(res1)) {
25319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
25320 }
25321 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25322 {
25323 PyThreadState* __tstate = wxPyBeginAllowThreads();
25324 result = (bool)((wxShowEvent const *)arg1)->GetShow();
25325 wxPyEndAllowThreads(__tstate);
25326 if (PyErr_Occurred()) SWIG_fail;
25327 }
25328 {
25329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25330 }
25331 return resultobj;
25332 fail:
25333 return NULL;
25334 }
25335
25336
25337 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25338 PyObject *obj;
25339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25340 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
25341 return SWIG_Py_Void();
25342 }
25343
25344 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25345 return SWIG_Python_InitShadowInstance(args);
25346 }
25347
25348 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25349 PyObject *resultobj = 0;
25350 int arg1 = (int) 0 ;
25351 bool arg2 = (bool) true ;
25352 wxIconizeEvent *result = 0 ;
25353 int val1 ;
25354 int ecode1 = 0 ;
25355 bool val2 ;
25356 int ecode2 = 0 ;
25357 PyObject * obj0 = 0 ;
25358 PyObject * obj1 = 0 ;
25359 char * kwnames[] = {
25360 (char *) "id",(char *) "iconized", NULL
25361 };
25362
25363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25364 if (obj0) {
25365 ecode1 = SWIG_AsVal_int(obj0, &val1);
25366 if (!SWIG_IsOK(ecode1)) {
25367 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
25368 }
25369 arg1 = static_cast< int >(val1);
25370 }
25371 if (obj1) {
25372 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25373 if (!SWIG_IsOK(ecode2)) {
25374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
25375 }
25376 arg2 = static_cast< bool >(val2);
25377 }
25378 {
25379 PyThreadState* __tstate = wxPyBeginAllowThreads();
25380 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
25381 wxPyEndAllowThreads(__tstate);
25382 if (PyErr_Occurred()) SWIG_fail;
25383 }
25384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
25385 return resultobj;
25386 fail:
25387 return NULL;
25388 }
25389
25390
25391 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25392 PyObject *resultobj = 0;
25393 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
25394 bool result;
25395 void *argp1 = 0 ;
25396 int res1 = 0 ;
25397 PyObject *swig_obj[1] ;
25398
25399 if (!args) SWIG_fail;
25400 swig_obj[0] = args;
25401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
25402 if (!SWIG_IsOK(res1)) {
25403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
25404 }
25405 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
25406 {
25407 PyThreadState* __tstate = wxPyBeginAllowThreads();
25408 result = (bool)(arg1)->Iconized();
25409 wxPyEndAllowThreads(__tstate);
25410 if (PyErr_Occurred()) SWIG_fail;
25411 }
25412 {
25413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25414 }
25415 return resultobj;
25416 fail:
25417 return NULL;
25418 }
25419
25420
25421 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25422 PyObject *obj;
25423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25424 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
25425 return SWIG_Py_Void();
25426 }
25427
25428 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25429 return SWIG_Python_InitShadowInstance(args);
25430 }
25431
25432 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25433 PyObject *resultobj = 0;
25434 int arg1 = (int) 0 ;
25435 wxMaximizeEvent *result = 0 ;
25436 int val1 ;
25437 int ecode1 = 0 ;
25438 PyObject * obj0 = 0 ;
25439 char * kwnames[] = {
25440 (char *) "id", NULL
25441 };
25442
25443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
25444 if (obj0) {
25445 ecode1 = SWIG_AsVal_int(obj0, &val1);
25446 if (!SWIG_IsOK(ecode1)) {
25447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
25448 }
25449 arg1 = static_cast< int >(val1);
25450 }
25451 {
25452 PyThreadState* __tstate = wxPyBeginAllowThreads();
25453 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
25454 wxPyEndAllowThreads(__tstate);
25455 if (PyErr_Occurred()) SWIG_fail;
25456 }
25457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
25458 return resultobj;
25459 fail:
25460 return NULL;
25461 }
25462
25463
25464 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25465 PyObject *obj;
25466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25467 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
25468 return SWIG_Py_Void();
25469 }
25470
25471 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25472 return SWIG_Python_InitShadowInstance(args);
25473 }
25474
25475 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25476 PyObject *resultobj = 0;
25477 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25478 wxPoint result;
25479 void *argp1 = 0 ;
25480 int res1 = 0 ;
25481 PyObject *swig_obj[1] ;
25482
25483 if (!args) SWIG_fail;
25484 swig_obj[0] = args;
25485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25486 if (!SWIG_IsOK(res1)) {
25487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25488 }
25489 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25490 {
25491 PyThreadState* __tstate = wxPyBeginAllowThreads();
25492 result = (arg1)->GetPosition();
25493 wxPyEndAllowThreads(__tstate);
25494 if (PyErr_Occurred()) SWIG_fail;
25495 }
25496 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25497 return resultobj;
25498 fail:
25499 return NULL;
25500 }
25501
25502
25503 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25504 PyObject *resultobj = 0;
25505 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25506 int result;
25507 void *argp1 = 0 ;
25508 int res1 = 0 ;
25509 PyObject *swig_obj[1] ;
25510
25511 if (!args) SWIG_fail;
25512 swig_obj[0] = args;
25513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25514 if (!SWIG_IsOK(res1)) {
25515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25516 }
25517 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25518 {
25519 PyThreadState* __tstate = wxPyBeginAllowThreads();
25520 result = (int)(arg1)->GetNumberOfFiles();
25521 wxPyEndAllowThreads(__tstate);
25522 if (PyErr_Occurred()) SWIG_fail;
25523 }
25524 resultobj = SWIG_From_int(static_cast< int >(result));
25525 return resultobj;
25526 fail:
25527 return NULL;
25528 }
25529
25530
25531 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25532 PyObject *resultobj = 0;
25533 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25534 PyObject *result = 0 ;
25535 void *argp1 = 0 ;
25536 int res1 = 0 ;
25537 PyObject *swig_obj[1] ;
25538
25539 if (!args) SWIG_fail;
25540 swig_obj[0] = args;
25541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25542 if (!SWIG_IsOK(res1)) {
25543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25544 }
25545 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25546 {
25547 PyThreadState* __tstate = wxPyBeginAllowThreads();
25548 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
25549 wxPyEndAllowThreads(__tstate);
25550 if (PyErr_Occurred()) SWIG_fail;
25551 }
25552 resultobj = result;
25553 return resultobj;
25554 fail:
25555 return NULL;
25556 }
25557
25558
25559 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25560 PyObject *obj;
25561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25562 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
25563 return SWIG_Py_Void();
25564 }
25565
25566 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25567 PyObject *resultobj = 0;
25568 int arg1 = (int) 0 ;
25569 wxUpdateUIEvent *result = 0 ;
25570 int val1 ;
25571 int ecode1 = 0 ;
25572 PyObject * obj0 = 0 ;
25573 char * kwnames[] = {
25574 (char *) "commandId", NULL
25575 };
25576
25577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
25578 if (obj0) {
25579 ecode1 = SWIG_AsVal_int(obj0, &val1);
25580 if (!SWIG_IsOK(ecode1)) {
25581 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
25582 }
25583 arg1 = static_cast< int >(val1);
25584 }
25585 {
25586 PyThreadState* __tstate = wxPyBeginAllowThreads();
25587 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25588 wxPyEndAllowThreads(__tstate);
25589 if (PyErr_Occurred()) SWIG_fail;
25590 }
25591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25592 return resultobj;
25593 fail:
25594 return NULL;
25595 }
25596
25597
25598 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25599 PyObject *resultobj = 0;
25600 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25601 bool result;
25602 void *argp1 = 0 ;
25603 int res1 = 0 ;
25604 PyObject *swig_obj[1] ;
25605
25606 if (!args) SWIG_fail;
25607 swig_obj[0] = args;
25608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25609 if (!SWIG_IsOK(res1)) {
25610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25611 }
25612 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25613 {
25614 PyThreadState* __tstate = wxPyBeginAllowThreads();
25615 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25616 wxPyEndAllowThreads(__tstate);
25617 if (PyErr_Occurred()) SWIG_fail;
25618 }
25619 {
25620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25621 }
25622 return resultobj;
25623 fail:
25624 return NULL;
25625 }
25626
25627
25628 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25629 PyObject *resultobj = 0;
25630 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25631 bool result;
25632 void *argp1 = 0 ;
25633 int res1 = 0 ;
25634 PyObject *swig_obj[1] ;
25635
25636 if (!args) SWIG_fail;
25637 swig_obj[0] = args;
25638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25639 if (!SWIG_IsOK(res1)) {
25640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25641 }
25642 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25643 {
25644 PyThreadState* __tstate = wxPyBeginAllowThreads();
25645 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25646 wxPyEndAllowThreads(__tstate);
25647 if (PyErr_Occurred()) SWIG_fail;
25648 }
25649 {
25650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25651 }
25652 return resultobj;
25653 fail:
25654 return NULL;
25655 }
25656
25657
25658 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25659 PyObject *resultobj = 0;
25660 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25661 bool result;
25662 void *argp1 = 0 ;
25663 int res1 = 0 ;
25664 PyObject *swig_obj[1] ;
25665
25666 if (!args) SWIG_fail;
25667 swig_obj[0] = args;
25668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25669 if (!SWIG_IsOK(res1)) {
25670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25671 }
25672 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25673 {
25674 PyThreadState* __tstate = wxPyBeginAllowThreads();
25675 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25676 wxPyEndAllowThreads(__tstate);
25677 if (PyErr_Occurred()) SWIG_fail;
25678 }
25679 {
25680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25681 }
25682 return resultobj;
25683 fail:
25684 return NULL;
25685 }
25686
25687
25688 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25689 PyObject *resultobj = 0;
25690 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25691 wxString result;
25692 void *argp1 = 0 ;
25693 int res1 = 0 ;
25694 PyObject *swig_obj[1] ;
25695
25696 if (!args) SWIG_fail;
25697 swig_obj[0] = args;
25698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25699 if (!SWIG_IsOK(res1)) {
25700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25701 }
25702 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25703 {
25704 PyThreadState* __tstate = wxPyBeginAllowThreads();
25705 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25706 wxPyEndAllowThreads(__tstate);
25707 if (PyErr_Occurred()) SWIG_fail;
25708 }
25709 {
25710 #if wxUSE_UNICODE
25711 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25712 #else
25713 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25714 #endif
25715 }
25716 return resultobj;
25717 fail:
25718 return NULL;
25719 }
25720
25721
25722 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25723 PyObject *resultobj = 0;
25724 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25725 bool result;
25726 void *argp1 = 0 ;
25727 int res1 = 0 ;
25728 PyObject *swig_obj[1] ;
25729
25730 if (!args) SWIG_fail;
25731 swig_obj[0] = args;
25732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25733 if (!SWIG_IsOK(res1)) {
25734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25735 }
25736 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25737 {
25738 PyThreadState* __tstate = wxPyBeginAllowThreads();
25739 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25740 wxPyEndAllowThreads(__tstate);
25741 if (PyErr_Occurred()) SWIG_fail;
25742 }
25743 {
25744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25745 }
25746 return resultobj;
25747 fail:
25748 return NULL;
25749 }
25750
25751
25752 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25753 PyObject *resultobj = 0;
25754 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25755 bool result;
25756 void *argp1 = 0 ;
25757 int res1 = 0 ;
25758 PyObject *swig_obj[1] ;
25759
25760 if (!args) SWIG_fail;
25761 swig_obj[0] = args;
25762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25763 if (!SWIG_IsOK(res1)) {
25764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25765 }
25766 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25767 {
25768 PyThreadState* __tstate = wxPyBeginAllowThreads();
25769 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25770 wxPyEndAllowThreads(__tstate);
25771 if (PyErr_Occurred()) SWIG_fail;
25772 }
25773 {
25774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25775 }
25776 return resultobj;
25777 fail:
25778 return NULL;
25779 }
25780
25781
25782 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25783 PyObject *resultobj = 0;
25784 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25785 bool result;
25786 void *argp1 = 0 ;
25787 int res1 = 0 ;
25788 PyObject *swig_obj[1] ;
25789
25790 if (!args) SWIG_fail;
25791 swig_obj[0] = args;
25792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25793 if (!SWIG_IsOK(res1)) {
25794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25795 }
25796 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25797 {
25798 PyThreadState* __tstate = wxPyBeginAllowThreads();
25799 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25800 wxPyEndAllowThreads(__tstate);
25801 if (PyErr_Occurred()) SWIG_fail;
25802 }
25803 {
25804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25805 }
25806 return resultobj;
25807 fail:
25808 return NULL;
25809 }
25810
25811
25812 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25813 PyObject *resultobj = 0;
25814 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25815 bool result;
25816 void *argp1 = 0 ;
25817 int res1 = 0 ;
25818 PyObject *swig_obj[1] ;
25819
25820 if (!args) SWIG_fail;
25821 swig_obj[0] = args;
25822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25823 if (!SWIG_IsOK(res1)) {
25824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25825 }
25826 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25827 {
25828 PyThreadState* __tstate = wxPyBeginAllowThreads();
25829 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25830 wxPyEndAllowThreads(__tstate);
25831 if (PyErr_Occurred()) SWIG_fail;
25832 }
25833 {
25834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25835 }
25836 return resultobj;
25837 fail:
25838 return NULL;
25839 }
25840
25841
25842 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25843 PyObject *resultobj = 0;
25844 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25845 bool arg2 ;
25846 void *argp1 = 0 ;
25847 int res1 = 0 ;
25848 bool val2 ;
25849 int ecode2 = 0 ;
25850 PyObject * obj0 = 0 ;
25851 PyObject * obj1 = 0 ;
25852 char * kwnames[] = {
25853 (char *) "self",(char *) "check", NULL
25854 };
25855
25856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25858 if (!SWIG_IsOK(res1)) {
25859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25860 }
25861 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25862 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25863 if (!SWIG_IsOK(ecode2)) {
25864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25865 }
25866 arg2 = static_cast< bool >(val2);
25867 {
25868 PyThreadState* __tstate = wxPyBeginAllowThreads();
25869 (arg1)->Check(arg2);
25870 wxPyEndAllowThreads(__tstate);
25871 if (PyErr_Occurred()) SWIG_fail;
25872 }
25873 resultobj = SWIG_Py_Void();
25874 return resultobj;
25875 fail:
25876 return NULL;
25877 }
25878
25879
25880 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25881 PyObject *resultobj = 0;
25882 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25883 bool arg2 ;
25884 void *argp1 = 0 ;
25885 int res1 = 0 ;
25886 bool val2 ;
25887 int ecode2 = 0 ;
25888 PyObject * obj0 = 0 ;
25889 PyObject * obj1 = 0 ;
25890 char * kwnames[] = {
25891 (char *) "self",(char *) "enable", NULL
25892 };
25893
25894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25896 if (!SWIG_IsOK(res1)) {
25897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25898 }
25899 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25900 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25901 if (!SWIG_IsOK(ecode2)) {
25902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25903 }
25904 arg2 = static_cast< bool >(val2);
25905 {
25906 PyThreadState* __tstate = wxPyBeginAllowThreads();
25907 (arg1)->Enable(arg2);
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 resultobj = SWIG_Py_Void();
25912 return resultobj;
25913 fail:
25914 return NULL;
25915 }
25916
25917
25918 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25919 PyObject *resultobj = 0;
25920 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25921 bool arg2 ;
25922 void *argp1 = 0 ;
25923 int res1 = 0 ;
25924 bool val2 ;
25925 int ecode2 = 0 ;
25926 PyObject * obj0 = 0 ;
25927 PyObject * obj1 = 0 ;
25928 char * kwnames[] = {
25929 (char *) "self",(char *) "show", NULL
25930 };
25931
25932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25934 if (!SWIG_IsOK(res1)) {
25935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25936 }
25937 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25938 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25939 if (!SWIG_IsOK(ecode2)) {
25940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25941 }
25942 arg2 = static_cast< bool >(val2);
25943 {
25944 PyThreadState* __tstate = wxPyBeginAllowThreads();
25945 (arg1)->Show(arg2);
25946 wxPyEndAllowThreads(__tstate);
25947 if (PyErr_Occurred()) SWIG_fail;
25948 }
25949 resultobj = SWIG_Py_Void();
25950 return resultobj;
25951 fail:
25952 return NULL;
25953 }
25954
25955
25956 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25957 PyObject *resultobj = 0;
25958 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25959 wxString *arg2 = 0 ;
25960 void *argp1 = 0 ;
25961 int res1 = 0 ;
25962 bool temp2 = false ;
25963 PyObject * obj0 = 0 ;
25964 PyObject * obj1 = 0 ;
25965 char * kwnames[] = {
25966 (char *) "self",(char *) "text", NULL
25967 };
25968
25969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25971 if (!SWIG_IsOK(res1)) {
25972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25973 }
25974 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25975 {
25976 arg2 = wxString_in_helper(obj1);
25977 if (arg2 == NULL) SWIG_fail;
25978 temp2 = true;
25979 }
25980 {
25981 PyThreadState* __tstate = wxPyBeginAllowThreads();
25982 (arg1)->SetText((wxString const &)*arg2);
25983 wxPyEndAllowThreads(__tstate);
25984 if (PyErr_Occurred()) SWIG_fail;
25985 }
25986 resultobj = SWIG_Py_Void();
25987 {
25988 if (temp2)
25989 delete arg2;
25990 }
25991 return resultobj;
25992 fail:
25993 {
25994 if (temp2)
25995 delete arg2;
25996 }
25997 return NULL;
25998 }
25999
26000
26001 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26002 PyObject *resultobj = 0;
26003 long arg1 ;
26004 long val1 ;
26005 int ecode1 = 0 ;
26006 PyObject * obj0 = 0 ;
26007 char * kwnames[] = {
26008 (char *) "updateInterval", NULL
26009 };
26010
26011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
26012 ecode1 = SWIG_AsVal_long(obj0, &val1);
26013 if (!SWIG_IsOK(ecode1)) {
26014 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
26015 }
26016 arg1 = static_cast< long >(val1);
26017 {
26018 PyThreadState* __tstate = wxPyBeginAllowThreads();
26019 wxUpdateUIEvent::SetUpdateInterval(arg1);
26020 wxPyEndAllowThreads(__tstate);
26021 if (PyErr_Occurred()) SWIG_fail;
26022 }
26023 resultobj = SWIG_Py_Void();
26024 return resultobj;
26025 fail:
26026 return NULL;
26027 }
26028
26029
26030 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26031 PyObject *resultobj = 0;
26032 long result;
26033
26034 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
26035 {
26036 PyThreadState* __tstate = wxPyBeginAllowThreads();
26037 result = (long)wxUpdateUIEvent::GetUpdateInterval();
26038 wxPyEndAllowThreads(__tstate);
26039 if (PyErr_Occurred()) SWIG_fail;
26040 }
26041 resultobj = SWIG_From_long(static_cast< long >(result));
26042 return resultobj;
26043 fail:
26044 return NULL;
26045 }
26046
26047
26048 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26049 PyObject *resultobj = 0;
26050 wxWindow *arg1 = (wxWindow *) 0 ;
26051 bool result;
26052 void *argp1 = 0 ;
26053 int res1 = 0 ;
26054 PyObject * obj0 = 0 ;
26055 char * kwnames[] = {
26056 (char *) "win", NULL
26057 };
26058
26059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
26060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26061 if (!SWIG_IsOK(res1)) {
26062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
26063 }
26064 arg1 = reinterpret_cast< wxWindow * >(argp1);
26065 {
26066 PyThreadState* __tstate = wxPyBeginAllowThreads();
26067 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
26068 wxPyEndAllowThreads(__tstate);
26069 if (PyErr_Occurred()) SWIG_fail;
26070 }
26071 {
26072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26073 }
26074 return resultobj;
26075 fail:
26076 return NULL;
26077 }
26078
26079
26080 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26081 PyObject *resultobj = 0;
26082
26083 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
26084 {
26085 PyThreadState* __tstate = wxPyBeginAllowThreads();
26086 wxUpdateUIEvent::ResetUpdateTime();
26087 wxPyEndAllowThreads(__tstate);
26088 if (PyErr_Occurred()) SWIG_fail;
26089 }
26090 resultobj = SWIG_Py_Void();
26091 return resultobj;
26092 fail:
26093 return NULL;
26094 }
26095
26096
26097 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26098 PyObject *resultobj = 0;
26099 wxUpdateUIMode arg1 ;
26100 int val1 ;
26101 int ecode1 = 0 ;
26102 PyObject * obj0 = 0 ;
26103 char * kwnames[] = {
26104 (char *) "mode", NULL
26105 };
26106
26107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26108 ecode1 = SWIG_AsVal_int(obj0, &val1);
26109 if (!SWIG_IsOK(ecode1)) {
26110 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
26111 }
26112 arg1 = static_cast< wxUpdateUIMode >(val1);
26113 {
26114 PyThreadState* __tstate = wxPyBeginAllowThreads();
26115 wxUpdateUIEvent::SetMode(arg1);
26116 wxPyEndAllowThreads(__tstate);
26117 if (PyErr_Occurred()) SWIG_fail;
26118 }
26119 resultobj = SWIG_Py_Void();
26120 return resultobj;
26121 fail:
26122 return NULL;
26123 }
26124
26125
26126 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26127 PyObject *resultobj = 0;
26128 wxUpdateUIMode result;
26129
26130 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
26131 {
26132 PyThreadState* __tstate = wxPyBeginAllowThreads();
26133 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
26134 wxPyEndAllowThreads(__tstate);
26135 if (PyErr_Occurred()) SWIG_fail;
26136 }
26137 resultobj = SWIG_From_int(static_cast< int >(result));
26138 return resultobj;
26139 fail:
26140 return NULL;
26141 }
26142
26143
26144 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26145 PyObject *obj;
26146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26147 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
26148 return SWIG_Py_Void();
26149 }
26150
26151 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26152 return SWIG_Python_InitShadowInstance(args);
26153 }
26154
26155 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26156 PyObject *resultobj = 0;
26157 wxSysColourChangedEvent *result = 0 ;
26158
26159 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
26160 {
26161 PyThreadState* __tstate = wxPyBeginAllowThreads();
26162 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
26163 wxPyEndAllowThreads(__tstate);
26164 if (PyErr_Occurred()) SWIG_fail;
26165 }
26166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
26167 return resultobj;
26168 fail:
26169 return NULL;
26170 }
26171
26172
26173 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26174 PyObject *obj;
26175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26176 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
26177 return SWIG_Py_Void();
26178 }
26179
26180 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26181 return SWIG_Python_InitShadowInstance(args);
26182 }
26183
26184 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26185 PyObject *resultobj = 0;
26186 int arg1 = (int) 0 ;
26187 wxWindow *arg2 = (wxWindow *) NULL ;
26188 wxMouseCaptureChangedEvent *result = 0 ;
26189 int val1 ;
26190 int ecode1 = 0 ;
26191 void *argp2 = 0 ;
26192 int res2 = 0 ;
26193 PyObject * obj0 = 0 ;
26194 PyObject * obj1 = 0 ;
26195 char * kwnames[] = {
26196 (char *) "winid",(char *) "gainedCapture", NULL
26197 };
26198
26199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26200 if (obj0) {
26201 ecode1 = SWIG_AsVal_int(obj0, &val1);
26202 if (!SWIG_IsOK(ecode1)) {
26203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
26204 }
26205 arg1 = static_cast< int >(val1);
26206 }
26207 if (obj1) {
26208 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26209 if (!SWIG_IsOK(res2)) {
26210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
26211 }
26212 arg2 = reinterpret_cast< wxWindow * >(argp2);
26213 }
26214 {
26215 PyThreadState* __tstate = wxPyBeginAllowThreads();
26216 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
26217 wxPyEndAllowThreads(__tstate);
26218 if (PyErr_Occurred()) SWIG_fail;
26219 }
26220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
26221 return resultobj;
26222 fail:
26223 return NULL;
26224 }
26225
26226
26227 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26228 PyObject *resultobj = 0;
26229 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
26230 wxWindow *result = 0 ;
26231 void *argp1 = 0 ;
26232 int res1 = 0 ;
26233 PyObject *swig_obj[1] ;
26234
26235 if (!args) SWIG_fail;
26236 swig_obj[0] = args;
26237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
26238 if (!SWIG_IsOK(res1)) {
26239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
26240 }
26241 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
26242 {
26243 PyThreadState* __tstate = wxPyBeginAllowThreads();
26244 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
26245 wxPyEndAllowThreads(__tstate);
26246 if (PyErr_Occurred()) SWIG_fail;
26247 }
26248 {
26249 resultobj = wxPyMake_wxObject(result, (bool)0);
26250 }
26251 return resultobj;
26252 fail:
26253 return NULL;
26254 }
26255
26256
26257 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26258 PyObject *obj;
26259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26260 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
26261 return SWIG_Py_Void();
26262 }
26263
26264 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26265 return SWIG_Python_InitShadowInstance(args);
26266 }
26267
26268 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26269 PyObject *resultobj = 0;
26270 int arg1 = (int) 0 ;
26271 wxMouseCaptureLostEvent *result = 0 ;
26272 int val1 ;
26273 int ecode1 = 0 ;
26274 PyObject * obj0 = 0 ;
26275 char * kwnames[] = {
26276 (char *) "winid", NULL
26277 };
26278
26279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
26280 if (obj0) {
26281 ecode1 = SWIG_AsVal_int(obj0, &val1);
26282 if (!SWIG_IsOK(ecode1)) {
26283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
26284 }
26285 arg1 = static_cast< int >(val1);
26286 }
26287 {
26288 PyThreadState* __tstate = wxPyBeginAllowThreads();
26289 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
26290 wxPyEndAllowThreads(__tstate);
26291 if (PyErr_Occurred()) SWIG_fail;
26292 }
26293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
26294 return resultobj;
26295 fail:
26296 return NULL;
26297 }
26298
26299
26300 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26301 PyObject *obj;
26302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26303 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
26304 return SWIG_Py_Void();
26305 }
26306
26307 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26308 return SWIG_Python_InitShadowInstance(args);
26309 }
26310
26311 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26312 PyObject *resultobj = 0;
26313 wxDisplayChangedEvent *result = 0 ;
26314
26315 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
26316 {
26317 PyThreadState* __tstate = wxPyBeginAllowThreads();
26318 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
26319 wxPyEndAllowThreads(__tstate);
26320 if (PyErr_Occurred()) SWIG_fail;
26321 }
26322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
26323 return resultobj;
26324 fail:
26325 return NULL;
26326 }
26327
26328
26329 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26330 PyObject *obj;
26331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26332 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
26333 return SWIG_Py_Void();
26334 }
26335
26336 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26337 return SWIG_Python_InitShadowInstance(args);
26338 }
26339
26340 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26341 PyObject *resultobj = 0;
26342 int arg1 = (int) 0 ;
26343 wxPaletteChangedEvent *result = 0 ;
26344 int val1 ;
26345 int ecode1 = 0 ;
26346 PyObject * obj0 = 0 ;
26347 char * kwnames[] = {
26348 (char *) "id", NULL
26349 };
26350
26351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
26352 if (obj0) {
26353 ecode1 = SWIG_AsVal_int(obj0, &val1);
26354 if (!SWIG_IsOK(ecode1)) {
26355 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
26356 }
26357 arg1 = static_cast< int >(val1);
26358 }
26359 {
26360 PyThreadState* __tstate = wxPyBeginAllowThreads();
26361 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
26362 wxPyEndAllowThreads(__tstate);
26363 if (PyErr_Occurred()) SWIG_fail;
26364 }
26365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
26366 return resultobj;
26367 fail:
26368 return NULL;
26369 }
26370
26371
26372 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26373 PyObject *resultobj = 0;
26374 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26375 wxWindow *arg2 = (wxWindow *) 0 ;
26376 void *argp1 = 0 ;
26377 int res1 = 0 ;
26378 void *argp2 = 0 ;
26379 int res2 = 0 ;
26380 PyObject * obj0 = 0 ;
26381 PyObject * obj1 = 0 ;
26382 char * kwnames[] = {
26383 (char *) "self",(char *) "win", NULL
26384 };
26385
26386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26388 if (!SWIG_IsOK(res1)) {
26389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26390 }
26391 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26392 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26393 if (!SWIG_IsOK(res2)) {
26394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26395 }
26396 arg2 = reinterpret_cast< wxWindow * >(argp2);
26397 {
26398 PyThreadState* __tstate = wxPyBeginAllowThreads();
26399 (arg1)->SetChangedWindow(arg2);
26400 wxPyEndAllowThreads(__tstate);
26401 if (PyErr_Occurred()) SWIG_fail;
26402 }
26403 resultobj = SWIG_Py_Void();
26404 return resultobj;
26405 fail:
26406 return NULL;
26407 }
26408
26409
26410 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26411 PyObject *resultobj = 0;
26412 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26413 wxWindow *result = 0 ;
26414 void *argp1 = 0 ;
26415 int res1 = 0 ;
26416 PyObject *swig_obj[1] ;
26417
26418 if (!args) SWIG_fail;
26419 swig_obj[0] = args;
26420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26421 if (!SWIG_IsOK(res1)) {
26422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26423 }
26424 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26425 {
26426 PyThreadState* __tstate = wxPyBeginAllowThreads();
26427 result = (wxWindow *)(arg1)->GetChangedWindow();
26428 wxPyEndAllowThreads(__tstate);
26429 if (PyErr_Occurred()) SWIG_fail;
26430 }
26431 {
26432 resultobj = wxPyMake_wxObject(result, (bool)0);
26433 }
26434 return resultobj;
26435 fail:
26436 return NULL;
26437 }
26438
26439
26440 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26441 PyObject *obj;
26442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26443 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
26444 return SWIG_Py_Void();
26445 }
26446
26447 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26448 return SWIG_Python_InitShadowInstance(args);
26449 }
26450
26451 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26452 PyObject *resultobj = 0;
26453 int arg1 = (int) 0 ;
26454 wxQueryNewPaletteEvent *result = 0 ;
26455 int val1 ;
26456 int ecode1 = 0 ;
26457 PyObject * obj0 = 0 ;
26458 char * kwnames[] = {
26459 (char *) "winid", NULL
26460 };
26461
26462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
26463 if (obj0) {
26464 ecode1 = SWIG_AsVal_int(obj0, &val1);
26465 if (!SWIG_IsOK(ecode1)) {
26466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
26467 }
26468 arg1 = static_cast< int >(val1);
26469 }
26470 {
26471 PyThreadState* __tstate = wxPyBeginAllowThreads();
26472 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
26473 wxPyEndAllowThreads(__tstate);
26474 if (PyErr_Occurred()) SWIG_fail;
26475 }
26476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
26477 return resultobj;
26478 fail:
26479 return NULL;
26480 }
26481
26482
26483 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26484 PyObject *resultobj = 0;
26485 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26486 bool arg2 ;
26487 void *argp1 = 0 ;
26488 int res1 = 0 ;
26489 bool val2 ;
26490 int ecode2 = 0 ;
26491 PyObject * obj0 = 0 ;
26492 PyObject * obj1 = 0 ;
26493 char * kwnames[] = {
26494 (char *) "self",(char *) "realized", NULL
26495 };
26496
26497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
26498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26499 if (!SWIG_IsOK(res1)) {
26500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
26501 }
26502 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26503 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26504 if (!SWIG_IsOK(ecode2)) {
26505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
26506 }
26507 arg2 = static_cast< bool >(val2);
26508 {
26509 PyThreadState* __tstate = wxPyBeginAllowThreads();
26510 (arg1)->SetPaletteRealized(arg2);
26511 wxPyEndAllowThreads(__tstate);
26512 if (PyErr_Occurred()) SWIG_fail;
26513 }
26514 resultobj = SWIG_Py_Void();
26515 return resultobj;
26516 fail:
26517 return NULL;
26518 }
26519
26520
26521 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26522 PyObject *resultobj = 0;
26523 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26524 bool result;
26525 void *argp1 = 0 ;
26526 int res1 = 0 ;
26527 PyObject *swig_obj[1] ;
26528
26529 if (!args) SWIG_fail;
26530 swig_obj[0] = args;
26531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26532 if (!SWIG_IsOK(res1)) {
26533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
26534 }
26535 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26536 {
26537 PyThreadState* __tstate = wxPyBeginAllowThreads();
26538 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
26539 wxPyEndAllowThreads(__tstate);
26540 if (PyErr_Occurred()) SWIG_fail;
26541 }
26542 {
26543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26544 }
26545 return resultobj;
26546 fail:
26547 return NULL;
26548 }
26549
26550
26551 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26552 PyObject *obj;
26553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26554 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
26555 return SWIG_Py_Void();
26556 }
26557
26558 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26559 return SWIG_Python_InitShadowInstance(args);
26560 }
26561
26562 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26563 PyObject *resultobj = 0;
26564 wxNavigationKeyEvent *result = 0 ;
26565
26566 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
26567 {
26568 PyThreadState* __tstate = wxPyBeginAllowThreads();
26569 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
26570 wxPyEndAllowThreads(__tstate);
26571 if (PyErr_Occurred()) SWIG_fail;
26572 }
26573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
26574 return resultobj;
26575 fail:
26576 return NULL;
26577 }
26578
26579
26580 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26581 PyObject *resultobj = 0;
26582 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26583 bool result;
26584 void *argp1 = 0 ;
26585 int res1 = 0 ;
26586 PyObject *swig_obj[1] ;
26587
26588 if (!args) SWIG_fail;
26589 swig_obj[0] = args;
26590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26591 if (!SWIG_IsOK(res1)) {
26592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26593 }
26594 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26595 {
26596 PyThreadState* __tstate = wxPyBeginAllowThreads();
26597 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26598 wxPyEndAllowThreads(__tstate);
26599 if (PyErr_Occurred()) SWIG_fail;
26600 }
26601 {
26602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26603 }
26604 return resultobj;
26605 fail:
26606 return NULL;
26607 }
26608
26609
26610 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26611 PyObject *resultobj = 0;
26612 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26613 bool arg2 ;
26614 void *argp1 = 0 ;
26615 int res1 = 0 ;
26616 bool val2 ;
26617 int ecode2 = 0 ;
26618 PyObject * obj0 = 0 ;
26619 PyObject * obj1 = 0 ;
26620 char * kwnames[] = {
26621 (char *) "self",(char *) "forward", NULL
26622 };
26623
26624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26626 if (!SWIG_IsOK(res1)) {
26627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26628 }
26629 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26630 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26631 if (!SWIG_IsOK(ecode2)) {
26632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26633 }
26634 arg2 = static_cast< bool >(val2);
26635 {
26636 PyThreadState* __tstate = wxPyBeginAllowThreads();
26637 (arg1)->SetDirection(arg2);
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_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26649 PyObject *resultobj = 0;
26650 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26651 bool result;
26652 void *argp1 = 0 ;
26653 int res1 = 0 ;
26654 PyObject *swig_obj[1] ;
26655
26656 if (!args) SWIG_fail;
26657 swig_obj[0] = args;
26658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26659 if (!SWIG_IsOK(res1)) {
26660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26661 }
26662 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26663 {
26664 PyThreadState* __tstate = wxPyBeginAllowThreads();
26665 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26666 wxPyEndAllowThreads(__tstate);
26667 if (PyErr_Occurred()) SWIG_fail;
26668 }
26669 {
26670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26671 }
26672 return resultobj;
26673 fail:
26674 return NULL;
26675 }
26676
26677
26678 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26679 PyObject *resultobj = 0;
26680 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26681 bool arg2 ;
26682 void *argp1 = 0 ;
26683 int res1 = 0 ;
26684 bool val2 ;
26685 int ecode2 = 0 ;
26686 PyObject * obj0 = 0 ;
26687 PyObject * obj1 = 0 ;
26688 char * kwnames[] = {
26689 (char *) "self",(char *) "ischange", NULL
26690 };
26691
26692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26694 if (!SWIG_IsOK(res1)) {
26695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26696 }
26697 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26698 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26699 if (!SWIG_IsOK(ecode2)) {
26700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26701 }
26702 arg2 = static_cast< bool >(val2);
26703 {
26704 PyThreadState* __tstate = wxPyBeginAllowThreads();
26705 (arg1)->SetWindowChange(arg2);
26706 wxPyEndAllowThreads(__tstate);
26707 if (PyErr_Occurred()) SWIG_fail;
26708 }
26709 resultobj = SWIG_Py_Void();
26710 return resultobj;
26711 fail:
26712 return NULL;
26713 }
26714
26715
26716 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26717 PyObject *resultobj = 0;
26718 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26719 bool result;
26720 void *argp1 = 0 ;
26721 int res1 = 0 ;
26722 PyObject *swig_obj[1] ;
26723
26724 if (!args) SWIG_fail;
26725 swig_obj[0] = args;
26726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26727 if (!SWIG_IsOK(res1)) {
26728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26729 }
26730 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26731 {
26732 PyThreadState* __tstate = wxPyBeginAllowThreads();
26733 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26734 wxPyEndAllowThreads(__tstate);
26735 if (PyErr_Occurred()) SWIG_fail;
26736 }
26737 {
26738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26739 }
26740 return resultobj;
26741 fail:
26742 return NULL;
26743 }
26744
26745
26746 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26747 PyObject *resultobj = 0;
26748 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26749 bool arg2 ;
26750 void *argp1 = 0 ;
26751 int res1 = 0 ;
26752 bool val2 ;
26753 int ecode2 = 0 ;
26754 PyObject * obj0 = 0 ;
26755 PyObject * obj1 = 0 ;
26756 char * kwnames[] = {
26757 (char *) "self",(char *) "bIs", NULL
26758 };
26759
26760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26762 if (!SWIG_IsOK(res1)) {
26763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26764 }
26765 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26766 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26767 if (!SWIG_IsOK(ecode2)) {
26768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26769 }
26770 arg2 = static_cast< bool >(val2);
26771 {
26772 PyThreadState* __tstate = wxPyBeginAllowThreads();
26773 (arg1)->SetFromTab(arg2);
26774 wxPyEndAllowThreads(__tstate);
26775 if (PyErr_Occurred()) SWIG_fail;
26776 }
26777 resultobj = SWIG_Py_Void();
26778 return resultobj;
26779 fail:
26780 return NULL;
26781 }
26782
26783
26784 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26785 PyObject *resultobj = 0;
26786 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26787 long arg2 ;
26788 void *argp1 = 0 ;
26789 int res1 = 0 ;
26790 long val2 ;
26791 int ecode2 = 0 ;
26792 PyObject * obj0 = 0 ;
26793 PyObject * obj1 = 0 ;
26794 char * kwnames[] = {
26795 (char *) "self",(char *) "flags", NULL
26796 };
26797
26798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26800 if (!SWIG_IsOK(res1)) {
26801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26802 }
26803 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26804 ecode2 = SWIG_AsVal_long(obj1, &val2);
26805 if (!SWIG_IsOK(ecode2)) {
26806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26807 }
26808 arg2 = static_cast< long >(val2);
26809 {
26810 PyThreadState* __tstate = wxPyBeginAllowThreads();
26811 (arg1)->SetFlags(arg2);
26812 wxPyEndAllowThreads(__tstate);
26813 if (PyErr_Occurred()) SWIG_fail;
26814 }
26815 resultobj = SWIG_Py_Void();
26816 return resultobj;
26817 fail:
26818 return NULL;
26819 }
26820
26821
26822 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26823 PyObject *resultobj = 0;
26824 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26825 wxWindow *result = 0 ;
26826 void *argp1 = 0 ;
26827 int res1 = 0 ;
26828 PyObject *swig_obj[1] ;
26829
26830 if (!args) SWIG_fail;
26831 swig_obj[0] = args;
26832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26833 if (!SWIG_IsOK(res1)) {
26834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26835 }
26836 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26837 {
26838 PyThreadState* __tstate = wxPyBeginAllowThreads();
26839 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26840 wxPyEndAllowThreads(__tstate);
26841 if (PyErr_Occurred()) SWIG_fail;
26842 }
26843 {
26844 resultobj = wxPyMake_wxObject(result, (bool)0);
26845 }
26846 return resultobj;
26847 fail:
26848 return NULL;
26849 }
26850
26851
26852 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26853 PyObject *resultobj = 0;
26854 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26855 wxWindow *arg2 = (wxWindow *) 0 ;
26856 void *argp1 = 0 ;
26857 int res1 = 0 ;
26858 void *argp2 = 0 ;
26859 int res2 = 0 ;
26860 PyObject * obj0 = 0 ;
26861 PyObject * obj1 = 0 ;
26862 char * kwnames[] = {
26863 (char *) "self",(char *) "win", NULL
26864 };
26865
26866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26868 if (!SWIG_IsOK(res1)) {
26869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26870 }
26871 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26872 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26873 if (!SWIG_IsOK(res2)) {
26874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26875 }
26876 arg2 = reinterpret_cast< wxWindow * >(argp2);
26877 {
26878 PyThreadState* __tstate = wxPyBeginAllowThreads();
26879 (arg1)->SetCurrentFocus(arg2);
26880 wxPyEndAllowThreads(__tstate);
26881 if (PyErr_Occurred()) SWIG_fail;
26882 }
26883 resultobj = SWIG_Py_Void();
26884 return resultobj;
26885 fail:
26886 return NULL;
26887 }
26888
26889
26890 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26891 PyObject *obj;
26892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26893 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26894 return SWIG_Py_Void();
26895 }
26896
26897 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26898 return SWIG_Python_InitShadowInstance(args);
26899 }
26900
26901 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26902 PyObject *resultobj = 0;
26903 wxWindow *arg1 = (wxWindow *) NULL ;
26904 wxWindowCreateEvent *result = 0 ;
26905 void *argp1 = 0 ;
26906 int res1 = 0 ;
26907 PyObject * obj0 = 0 ;
26908 char * kwnames[] = {
26909 (char *) "win", NULL
26910 };
26911
26912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26913 if (obj0) {
26914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26915 if (!SWIG_IsOK(res1)) {
26916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26917 }
26918 arg1 = reinterpret_cast< wxWindow * >(argp1);
26919 }
26920 {
26921 PyThreadState* __tstate = wxPyBeginAllowThreads();
26922 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26923 wxPyEndAllowThreads(__tstate);
26924 if (PyErr_Occurred()) SWIG_fail;
26925 }
26926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26927 return resultobj;
26928 fail:
26929 return NULL;
26930 }
26931
26932
26933 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26934 PyObject *resultobj = 0;
26935 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26936 wxWindow *result = 0 ;
26937 void *argp1 = 0 ;
26938 int res1 = 0 ;
26939 PyObject *swig_obj[1] ;
26940
26941 if (!args) SWIG_fail;
26942 swig_obj[0] = args;
26943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26944 if (!SWIG_IsOK(res1)) {
26945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26946 }
26947 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26948 {
26949 PyThreadState* __tstate = wxPyBeginAllowThreads();
26950 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26951 wxPyEndAllowThreads(__tstate);
26952 if (PyErr_Occurred()) SWIG_fail;
26953 }
26954 {
26955 resultobj = wxPyMake_wxObject(result, (bool)0);
26956 }
26957 return resultobj;
26958 fail:
26959 return NULL;
26960 }
26961
26962
26963 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26964 PyObject *obj;
26965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26966 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26967 return SWIG_Py_Void();
26968 }
26969
26970 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26971 return SWIG_Python_InitShadowInstance(args);
26972 }
26973
26974 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26975 PyObject *resultobj = 0;
26976 wxWindow *arg1 = (wxWindow *) NULL ;
26977 wxWindowDestroyEvent *result = 0 ;
26978 void *argp1 = 0 ;
26979 int res1 = 0 ;
26980 PyObject * obj0 = 0 ;
26981 char * kwnames[] = {
26982 (char *) "win", NULL
26983 };
26984
26985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26986 if (obj0) {
26987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26988 if (!SWIG_IsOK(res1)) {
26989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26990 }
26991 arg1 = reinterpret_cast< wxWindow * >(argp1);
26992 }
26993 {
26994 PyThreadState* __tstate = wxPyBeginAllowThreads();
26995 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26996 wxPyEndAllowThreads(__tstate);
26997 if (PyErr_Occurred()) SWIG_fail;
26998 }
26999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
27000 return resultobj;
27001 fail:
27002 return NULL;
27003 }
27004
27005
27006 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27007 PyObject *resultobj = 0;
27008 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
27009 wxWindow *result = 0 ;
27010 void *argp1 = 0 ;
27011 int res1 = 0 ;
27012 PyObject *swig_obj[1] ;
27013
27014 if (!args) SWIG_fail;
27015 swig_obj[0] = args;
27016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
27017 if (!SWIG_IsOK(res1)) {
27018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
27019 }
27020 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
27021 {
27022 PyThreadState* __tstate = wxPyBeginAllowThreads();
27023 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
27024 wxPyEndAllowThreads(__tstate);
27025 if (PyErr_Occurred()) SWIG_fail;
27026 }
27027 {
27028 resultobj = wxPyMake_wxObject(result, (bool)0);
27029 }
27030 return resultobj;
27031 fail:
27032 return NULL;
27033 }
27034
27035
27036 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27037 PyObject *obj;
27038 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27039 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
27040 return SWIG_Py_Void();
27041 }
27042
27043 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27044 return SWIG_Python_InitShadowInstance(args);
27045 }
27046
27047 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27048 PyObject *resultobj = 0;
27049 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27050 int arg2 = (int) 0 ;
27051 wxPoint const &arg3_defvalue = wxDefaultPosition ;
27052 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
27053 wxContextMenuEvent *result = 0 ;
27054 int val1 ;
27055 int ecode1 = 0 ;
27056 int val2 ;
27057 int ecode2 = 0 ;
27058 wxPoint temp3 ;
27059 PyObject * obj0 = 0 ;
27060 PyObject * obj1 = 0 ;
27061 PyObject * obj2 = 0 ;
27062 char * kwnames[] = {
27063 (char *) "type",(char *) "winid",(char *) "pt", NULL
27064 };
27065
27066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27067 if (obj0) {
27068 ecode1 = SWIG_AsVal_int(obj0, &val1);
27069 if (!SWIG_IsOK(ecode1)) {
27070 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27071 }
27072 arg1 = static_cast< wxEventType >(val1);
27073 }
27074 if (obj1) {
27075 ecode2 = SWIG_AsVal_int(obj1, &val2);
27076 if (!SWIG_IsOK(ecode2)) {
27077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
27078 }
27079 arg2 = static_cast< int >(val2);
27080 }
27081 if (obj2) {
27082 {
27083 arg3 = &temp3;
27084 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
27085 }
27086 }
27087 {
27088 PyThreadState* __tstate = wxPyBeginAllowThreads();
27089 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
27090 wxPyEndAllowThreads(__tstate);
27091 if (PyErr_Occurred()) SWIG_fail;
27092 }
27093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
27094 return resultobj;
27095 fail:
27096 return NULL;
27097 }
27098
27099
27100 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27101 PyObject *resultobj = 0;
27102 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27103 wxPoint *result = 0 ;
27104 void *argp1 = 0 ;
27105 int res1 = 0 ;
27106 PyObject *swig_obj[1] ;
27107
27108 if (!args) SWIG_fail;
27109 swig_obj[0] = args;
27110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27111 if (!SWIG_IsOK(res1)) {
27112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
27113 }
27114 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27115 {
27116 PyThreadState* __tstate = wxPyBeginAllowThreads();
27117 {
27118 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
27119 result = (wxPoint *) &_result_ref;
27120 }
27121 wxPyEndAllowThreads(__tstate);
27122 if (PyErr_Occurred()) SWIG_fail;
27123 }
27124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
27125 return resultobj;
27126 fail:
27127 return NULL;
27128 }
27129
27130
27131 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27132 PyObject *resultobj = 0;
27133 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27134 wxPoint *arg2 = 0 ;
27135 void *argp1 = 0 ;
27136 int res1 = 0 ;
27137 wxPoint temp2 ;
27138 PyObject * obj0 = 0 ;
27139 PyObject * obj1 = 0 ;
27140 char * kwnames[] = {
27141 (char *) "self",(char *) "pos", NULL
27142 };
27143
27144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
27145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27146 if (!SWIG_IsOK(res1)) {
27147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
27148 }
27149 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27150 {
27151 arg2 = &temp2;
27152 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27153 }
27154 {
27155 PyThreadState* __tstate = wxPyBeginAllowThreads();
27156 (arg1)->SetPosition((wxPoint const &)*arg2);
27157 wxPyEndAllowThreads(__tstate);
27158 if (PyErr_Occurred()) SWIG_fail;
27159 }
27160 resultobj = SWIG_Py_Void();
27161 return resultobj;
27162 fail:
27163 return NULL;
27164 }
27165
27166
27167 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27168 PyObject *obj;
27169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27170 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
27171 return SWIG_Py_Void();
27172 }
27173
27174 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27175 return SWIG_Python_InitShadowInstance(args);
27176 }
27177
27178 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27179 PyObject *resultobj = 0;
27180 wxIdleEvent *result = 0 ;
27181
27182 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
27183 {
27184 PyThreadState* __tstate = wxPyBeginAllowThreads();
27185 result = (wxIdleEvent *)new wxIdleEvent();
27186 wxPyEndAllowThreads(__tstate);
27187 if (PyErr_Occurred()) SWIG_fail;
27188 }
27189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
27190 return resultobj;
27191 fail:
27192 return NULL;
27193 }
27194
27195
27196 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27197 PyObject *resultobj = 0;
27198 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27199 bool arg2 = (bool) true ;
27200 void *argp1 = 0 ;
27201 int res1 = 0 ;
27202 bool val2 ;
27203 int ecode2 = 0 ;
27204 PyObject * obj0 = 0 ;
27205 PyObject * obj1 = 0 ;
27206 char * kwnames[] = {
27207 (char *) "self",(char *) "needMore", NULL
27208 };
27209
27210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
27211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27212 if (!SWIG_IsOK(res1)) {
27213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
27214 }
27215 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27216 if (obj1) {
27217 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27218 if (!SWIG_IsOK(ecode2)) {
27219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
27220 }
27221 arg2 = static_cast< bool >(val2);
27222 }
27223 {
27224 PyThreadState* __tstate = wxPyBeginAllowThreads();
27225 (arg1)->RequestMore(arg2);
27226 wxPyEndAllowThreads(__tstate);
27227 if (PyErr_Occurred()) SWIG_fail;
27228 }
27229 resultobj = SWIG_Py_Void();
27230 return resultobj;
27231 fail:
27232 return NULL;
27233 }
27234
27235
27236 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27237 PyObject *resultobj = 0;
27238 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27239 bool result;
27240 void *argp1 = 0 ;
27241 int res1 = 0 ;
27242 PyObject *swig_obj[1] ;
27243
27244 if (!args) SWIG_fail;
27245 swig_obj[0] = args;
27246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27247 if (!SWIG_IsOK(res1)) {
27248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
27249 }
27250 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27251 {
27252 PyThreadState* __tstate = wxPyBeginAllowThreads();
27253 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
27254 wxPyEndAllowThreads(__tstate);
27255 if (PyErr_Occurred()) SWIG_fail;
27256 }
27257 {
27258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27259 }
27260 return resultobj;
27261 fail:
27262 return NULL;
27263 }
27264
27265
27266 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27267 PyObject *resultobj = 0;
27268 wxIdleMode arg1 ;
27269 int val1 ;
27270 int ecode1 = 0 ;
27271 PyObject * obj0 = 0 ;
27272 char * kwnames[] = {
27273 (char *) "mode", NULL
27274 };
27275
27276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
27277 ecode1 = SWIG_AsVal_int(obj0, &val1);
27278 if (!SWIG_IsOK(ecode1)) {
27279 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
27280 }
27281 arg1 = static_cast< wxIdleMode >(val1);
27282 {
27283 PyThreadState* __tstate = wxPyBeginAllowThreads();
27284 wxIdleEvent::SetMode(arg1);
27285 wxPyEndAllowThreads(__tstate);
27286 if (PyErr_Occurred()) SWIG_fail;
27287 }
27288 resultobj = SWIG_Py_Void();
27289 return resultobj;
27290 fail:
27291 return NULL;
27292 }
27293
27294
27295 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27296 PyObject *resultobj = 0;
27297 wxIdleMode result;
27298
27299 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
27300 {
27301 PyThreadState* __tstate = wxPyBeginAllowThreads();
27302 result = (wxIdleMode)wxIdleEvent::GetMode();
27303 wxPyEndAllowThreads(__tstate);
27304 if (PyErr_Occurred()) SWIG_fail;
27305 }
27306 resultobj = SWIG_From_int(static_cast< int >(result));
27307 return resultobj;
27308 fail:
27309 return NULL;
27310 }
27311
27312
27313 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27314 PyObject *resultobj = 0;
27315 wxWindow *arg1 = (wxWindow *) 0 ;
27316 bool result;
27317 void *argp1 = 0 ;
27318 int res1 = 0 ;
27319 PyObject * obj0 = 0 ;
27320 char * kwnames[] = {
27321 (char *) "win", NULL
27322 };
27323
27324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
27325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27326 if (!SWIG_IsOK(res1)) {
27327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
27328 }
27329 arg1 = reinterpret_cast< wxWindow * >(argp1);
27330 {
27331 PyThreadState* __tstate = wxPyBeginAllowThreads();
27332 result = (bool)wxIdleEvent::CanSend(arg1);
27333 wxPyEndAllowThreads(__tstate);
27334 if (PyErr_Occurred()) SWIG_fail;
27335 }
27336 {
27337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27338 }
27339 return resultobj;
27340 fail:
27341 return NULL;
27342 }
27343
27344
27345 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27346 PyObject *obj;
27347 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27348 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
27349 return SWIG_Py_Void();
27350 }
27351
27352 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27353 return SWIG_Python_InitShadowInstance(args);
27354 }
27355
27356 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27357 PyObject *resultobj = 0;
27358 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27359 int arg2 = (int) 0 ;
27360 wxClipboardTextEvent *result = 0 ;
27361 int val1 ;
27362 int ecode1 = 0 ;
27363 int val2 ;
27364 int ecode2 = 0 ;
27365 PyObject * obj0 = 0 ;
27366 PyObject * obj1 = 0 ;
27367 char * kwnames[] = {
27368 (char *) "type",(char *) "winid", NULL
27369 };
27370
27371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27372 if (obj0) {
27373 ecode1 = SWIG_AsVal_int(obj0, &val1);
27374 if (!SWIG_IsOK(ecode1)) {
27375 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27376 }
27377 arg1 = static_cast< wxEventType >(val1);
27378 }
27379 if (obj1) {
27380 ecode2 = SWIG_AsVal_int(obj1, &val2);
27381 if (!SWIG_IsOK(ecode2)) {
27382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
27383 }
27384 arg2 = static_cast< int >(val2);
27385 }
27386 {
27387 PyThreadState* __tstate = wxPyBeginAllowThreads();
27388 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
27389 wxPyEndAllowThreads(__tstate);
27390 if (PyErr_Occurred()) SWIG_fail;
27391 }
27392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
27393 return resultobj;
27394 fail:
27395 return NULL;
27396 }
27397
27398
27399 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27400 PyObject *obj;
27401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27402 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
27403 return SWIG_Py_Void();
27404 }
27405
27406 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27407 return SWIG_Python_InitShadowInstance(args);
27408 }
27409
27410 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27411 PyObject *resultobj = 0;
27412 int arg1 = (int) 0 ;
27413 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
27414 wxPyEvent *result = 0 ;
27415 int val1 ;
27416 int ecode1 = 0 ;
27417 int val2 ;
27418 int ecode2 = 0 ;
27419 PyObject * obj0 = 0 ;
27420 PyObject * obj1 = 0 ;
27421 char * kwnames[] = {
27422 (char *) "winid",(char *) "eventType", NULL
27423 };
27424
27425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27426 if (obj0) {
27427 ecode1 = SWIG_AsVal_int(obj0, &val1);
27428 if (!SWIG_IsOK(ecode1)) {
27429 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
27430 }
27431 arg1 = static_cast< int >(val1);
27432 }
27433 if (obj1) {
27434 ecode2 = SWIG_AsVal_int(obj1, &val2);
27435 if (!SWIG_IsOK(ecode2)) {
27436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
27437 }
27438 arg2 = static_cast< wxEventType >(val2);
27439 }
27440 {
27441 PyThreadState* __tstate = wxPyBeginAllowThreads();
27442 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
27443 wxPyEndAllowThreads(__tstate);
27444 if (PyErr_Occurred()) SWIG_fail;
27445 }
27446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
27447 return resultobj;
27448 fail:
27449 return NULL;
27450 }
27451
27452
27453 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27454 PyObject *resultobj = 0;
27455 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27456 void *argp1 = 0 ;
27457 int res1 = 0 ;
27458 PyObject *swig_obj[1] ;
27459
27460 if (!args) SWIG_fail;
27461 swig_obj[0] = args;
27462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
27463 if (!SWIG_IsOK(res1)) {
27464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27465 }
27466 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27467 {
27468 PyThreadState* __tstate = wxPyBeginAllowThreads();
27469 delete arg1;
27470
27471 wxPyEndAllowThreads(__tstate);
27472 if (PyErr_Occurred()) SWIG_fail;
27473 }
27474 resultobj = SWIG_Py_Void();
27475 return resultobj;
27476 fail:
27477 return NULL;
27478 }
27479
27480
27481 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27482 PyObject *resultobj = 0;
27483 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27484 PyObject *arg2 = (PyObject *) 0 ;
27485 void *argp1 = 0 ;
27486 int res1 = 0 ;
27487 PyObject * obj0 = 0 ;
27488 PyObject * obj1 = 0 ;
27489 char * kwnames[] = {
27490 (char *) "self",(char *) "self", NULL
27491 };
27492
27493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27495 if (!SWIG_IsOK(res1)) {
27496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27497 }
27498 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27499 arg2 = obj1;
27500 {
27501 PyThreadState* __tstate = wxPyBeginAllowThreads();
27502 (arg1)->SetSelf(arg2);
27503 wxPyEndAllowThreads(__tstate);
27504 if (PyErr_Occurred()) SWIG_fail;
27505 }
27506 resultobj = SWIG_Py_Void();
27507 return resultobj;
27508 fail:
27509 return NULL;
27510 }
27511
27512
27513 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27514 PyObject *resultobj = 0;
27515 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27516 PyObject *result = 0 ;
27517 void *argp1 = 0 ;
27518 int res1 = 0 ;
27519 PyObject *swig_obj[1] ;
27520
27521 if (!args) SWIG_fail;
27522 swig_obj[0] = args;
27523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27524 if (!SWIG_IsOK(res1)) {
27525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27526 }
27527 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27528 {
27529 PyThreadState* __tstate = wxPyBeginAllowThreads();
27530 result = (PyObject *)(arg1)->GetSelf();
27531 wxPyEndAllowThreads(__tstate);
27532 if (PyErr_Occurred()) SWIG_fail;
27533 }
27534 resultobj = result;
27535 return resultobj;
27536 fail:
27537 return NULL;
27538 }
27539
27540
27541 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27542 PyObject *obj;
27543 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27544 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
27545 return SWIG_Py_Void();
27546 }
27547
27548 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27549 return SWIG_Python_InitShadowInstance(args);
27550 }
27551
27552 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27553 PyObject *resultobj = 0;
27554 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27555 int arg2 = (int) 0 ;
27556 wxPyCommandEvent *result = 0 ;
27557 int val1 ;
27558 int ecode1 = 0 ;
27559 int val2 ;
27560 int ecode2 = 0 ;
27561 PyObject * obj0 = 0 ;
27562 PyObject * obj1 = 0 ;
27563 char * kwnames[] = {
27564 (char *) "eventType",(char *) "id", NULL
27565 };
27566
27567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27568 if (obj0) {
27569 ecode1 = SWIG_AsVal_int(obj0, &val1);
27570 if (!SWIG_IsOK(ecode1)) {
27571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27572 }
27573 arg1 = static_cast< wxEventType >(val1);
27574 }
27575 if (obj1) {
27576 ecode2 = SWIG_AsVal_int(obj1, &val2);
27577 if (!SWIG_IsOK(ecode2)) {
27578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
27579 }
27580 arg2 = static_cast< int >(val2);
27581 }
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27596 PyObject *resultobj = 0;
27597 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27598 void *argp1 = 0 ;
27599 int res1 = 0 ;
27600 PyObject *swig_obj[1] ;
27601
27602 if (!args) SWIG_fail;
27603 swig_obj[0] = args;
27604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27605 if (!SWIG_IsOK(res1)) {
27606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27607 }
27608 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27609 {
27610 PyThreadState* __tstate = wxPyBeginAllowThreads();
27611 delete arg1;
27612
27613 wxPyEndAllowThreads(__tstate);
27614 if (PyErr_Occurred()) SWIG_fail;
27615 }
27616 resultobj = SWIG_Py_Void();
27617 return resultobj;
27618 fail:
27619 return NULL;
27620 }
27621
27622
27623 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27624 PyObject *resultobj = 0;
27625 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27626 PyObject *arg2 = (PyObject *) 0 ;
27627 void *argp1 = 0 ;
27628 int res1 = 0 ;
27629 PyObject * obj0 = 0 ;
27630 PyObject * obj1 = 0 ;
27631 char * kwnames[] = {
27632 (char *) "self",(char *) "self", NULL
27633 };
27634
27635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27637 if (!SWIG_IsOK(res1)) {
27638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27639 }
27640 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27641 arg2 = obj1;
27642 {
27643 PyThreadState* __tstate = wxPyBeginAllowThreads();
27644 (arg1)->SetSelf(arg2);
27645 wxPyEndAllowThreads(__tstate);
27646 if (PyErr_Occurred()) SWIG_fail;
27647 }
27648 resultobj = SWIG_Py_Void();
27649 return resultobj;
27650 fail:
27651 return NULL;
27652 }
27653
27654
27655 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27656 PyObject *resultobj = 0;
27657 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27658 PyObject *result = 0 ;
27659 void *argp1 = 0 ;
27660 int res1 = 0 ;
27661 PyObject *swig_obj[1] ;
27662
27663 if (!args) SWIG_fail;
27664 swig_obj[0] = args;
27665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27666 if (!SWIG_IsOK(res1)) {
27667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27668 }
27669 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27670 {
27671 PyThreadState* __tstate = wxPyBeginAllowThreads();
27672 result = (PyObject *)(arg1)->GetSelf();
27673 wxPyEndAllowThreads(__tstate);
27674 if (PyErr_Occurred()) SWIG_fail;
27675 }
27676 resultobj = result;
27677 return resultobj;
27678 fail:
27679 return NULL;
27680 }
27681
27682
27683 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27684 PyObject *obj;
27685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27686 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27687 return SWIG_Py_Void();
27688 }
27689
27690 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27691 return SWIG_Python_InitShadowInstance(args);
27692 }
27693
27694 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27695 PyObject *resultobj = 0;
27696 wxWindow *arg1 = (wxWindow *) 0 ;
27697 wxDateTime *arg2 = 0 ;
27698 wxEventType arg3 ;
27699 wxDateEvent *result = 0 ;
27700 void *argp1 = 0 ;
27701 int res1 = 0 ;
27702 void *argp2 = 0 ;
27703 int res2 = 0 ;
27704 int val3 ;
27705 int ecode3 = 0 ;
27706 PyObject * obj0 = 0 ;
27707 PyObject * obj1 = 0 ;
27708 PyObject * obj2 = 0 ;
27709 char * kwnames[] = {
27710 (char *) "win",(char *) "dt",(char *) "type", NULL
27711 };
27712
27713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27715 if (!SWIG_IsOK(res1)) {
27716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27717 }
27718 arg1 = reinterpret_cast< wxWindow * >(argp1);
27719 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27720 if (!SWIG_IsOK(res2)) {
27721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27722 }
27723 if (!argp2) {
27724 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27725 }
27726 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27727 ecode3 = SWIG_AsVal_int(obj2, &val3);
27728 if (!SWIG_IsOK(ecode3)) {
27729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27730 }
27731 arg3 = static_cast< wxEventType >(val3);
27732 {
27733 PyThreadState* __tstate = wxPyBeginAllowThreads();
27734 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27735 wxPyEndAllowThreads(__tstate);
27736 if (PyErr_Occurred()) SWIG_fail;
27737 }
27738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27739 return resultobj;
27740 fail:
27741 return NULL;
27742 }
27743
27744
27745 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27746 PyObject *resultobj = 0;
27747 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27748 wxDateTime *result = 0 ;
27749 void *argp1 = 0 ;
27750 int res1 = 0 ;
27751 PyObject *swig_obj[1] ;
27752
27753 if (!args) SWIG_fail;
27754 swig_obj[0] = args;
27755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27756 if (!SWIG_IsOK(res1)) {
27757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27758 }
27759 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27760 {
27761 PyThreadState* __tstate = wxPyBeginAllowThreads();
27762 {
27763 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27764 result = (wxDateTime *) &_result_ref;
27765 }
27766 wxPyEndAllowThreads(__tstate);
27767 if (PyErr_Occurred()) SWIG_fail;
27768 }
27769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27770 return resultobj;
27771 fail:
27772 return NULL;
27773 }
27774
27775
27776 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27777 PyObject *resultobj = 0;
27778 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27779 wxDateTime *arg2 = 0 ;
27780 void *argp1 = 0 ;
27781 int res1 = 0 ;
27782 void *argp2 = 0 ;
27783 int res2 = 0 ;
27784 PyObject * obj0 = 0 ;
27785 PyObject * obj1 = 0 ;
27786 char * kwnames[] = {
27787 (char *) "self",(char *) "date", NULL
27788 };
27789
27790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27792 if (!SWIG_IsOK(res1)) {
27793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27794 }
27795 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27796 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27797 if (!SWIG_IsOK(res2)) {
27798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27799 }
27800 if (!argp2) {
27801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27802 }
27803 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27804 {
27805 PyThreadState* __tstate = wxPyBeginAllowThreads();
27806 (arg1)->SetDate((wxDateTime const &)*arg2);
27807 wxPyEndAllowThreads(__tstate);
27808 if (PyErr_Occurred()) SWIG_fail;
27809 }
27810 resultobj = SWIG_Py_Void();
27811 return resultobj;
27812 fail:
27813 return NULL;
27814 }
27815
27816
27817 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27818 PyObject *obj;
27819 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27820 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27821 return SWIG_Py_Void();
27822 }
27823
27824 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27825 return SWIG_Python_InitShadowInstance(args);
27826 }
27827
27828 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27829 PyObject *resultobj = 0;
27830 wxPyApp *result = 0 ;
27831
27832 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27833 {
27834 PyThreadState* __tstate = wxPyBeginAllowThreads();
27835 result = (wxPyApp *)new_wxPyApp();
27836 wxPyEndAllowThreads(__tstate);
27837 if (PyErr_Occurred()) SWIG_fail;
27838 }
27839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27840 return resultobj;
27841 fail:
27842 return NULL;
27843 }
27844
27845
27846 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27847 PyObject *resultobj = 0;
27848 wxPyApp *arg1 = (wxPyApp *) 0 ;
27849 void *argp1 = 0 ;
27850 int res1 = 0 ;
27851 PyObject *swig_obj[1] ;
27852
27853 if (!args) SWIG_fail;
27854 swig_obj[0] = args;
27855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27856 if (!SWIG_IsOK(res1)) {
27857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27858 }
27859 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27860 {
27861 PyThreadState* __tstate = wxPyBeginAllowThreads();
27862 delete arg1;
27863
27864 wxPyEndAllowThreads(__tstate);
27865 if (PyErr_Occurred()) SWIG_fail;
27866 }
27867 resultobj = SWIG_Py_Void();
27868 return resultobj;
27869 fail:
27870 return NULL;
27871 }
27872
27873
27874 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27875 PyObject *resultobj = 0;
27876 wxPyApp *arg1 = (wxPyApp *) 0 ;
27877 PyObject *arg2 = (PyObject *) 0 ;
27878 PyObject *arg3 = (PyObject *) 0 ;
27879 bool arg4 ;
27880 void *argp1 = 0 ;
27881 int res1 = 0 ;
27882 bool val4 ;
27883 int ecode4 = 0 ;
27884 PyObject * obj0 = 0 ;
27885 PyObject * obj1 = 0 ;
27886 PyObject * obj2 = 0 ;
27887 PyObject * obj3 = 0 ;
27888 char * kwnames[] = {
27889 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27890 };
27891
27892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27894 if (!SWIG_IsOK(res1)) {
27895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27896 }
27897 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27898 arg2 = obj1;
27899 arg3 = obj2;
27900 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27901 if (!SWIG_IsOK(ecode4)) {
27902 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27903 }
27904 arg4 = static_cast< bool >(val4);
27905 {
27906 PyThreadState* __tstate = wxPyBeginAllowThreads();
27907 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27908 wxPyEndAllowThreads(__tstate);
27909 if (PyErr_Occurred()) SWIG_fail;
27910 }
27911 resultobj = SWIG_Py_Void();
27912 return resultobj;
27913 fail:
27914 return NULL;
27915 }
27916
27917
27918 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27919 PyObject *resultobj = 0;
27920 wxPyApp *arg1 = (wxPyApp *) 0 ;
27921 wxString result;
27922 void *argp1 = 0 ;
27923 int res1 = 0 ;
27924 PyObject *swig_obj[1] ;
27925
27926 if (!args) SWIG_fail;
27927 swig_obj[0] = args;
27928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27929 if (!SWIG_IsOK(res1)) {
27930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27931 }
27932 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27933 {
27934 PyThreadState* __tstate = wxPyBeginAllowThreads();
27935 result = ((wxPyApp const *)arg1)->GetAppName();
27936 wxPyEndAllowThreads(__tstate);
27937 if (PyErr_Occurred()) SWIG_fail;
27938 }
27939 {
27940 #if wxUSE_UNICODE
27941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27942 #else
27943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27944 #endif
27945 }
27946 return resultobj;
27947 fail:
27948 return NULL;
27949 }
27950
27951
27952 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27953 PyObject *resultobj = 0;
27954 wxPyApp *arg1 = (wxPyApp *) 0 ;
27955 wxString *arg2 = 0 ;
27956 void *argp1 = 0 ;
27957 int res1 = 0 ;
27958 bool temp2 = false ;
27959 PyObject * obj0 = 0 ;
27960 PyObject * obj1 = 0 ;
27961 char * kwnames[] = {
27962 (char *) "self",(char *) "name", NULL
27963 };
27964
27965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27967 if (!SWIG_IsOK(res1)) {
27968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27969 }
27970 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27971 {
27972 arg2 = wxString_in_helper(obj1);
27973 if (arg2 == NULL) SWIG_fail;
27974 temp2 = true;
27975 }
27976 {
27977 PyThreadState* __tstate = wxPyBeginAllowThreads();
27978 (arg1)->SetAppName((wxString const &)*arg2);
27979 wxPyEndAllowThreads(__tstate);
27980 if (PyErr_Occurred()) SWIG_fail;
27981 }
27982 resultobj = SWIG_Py_Void();
27983 {
27984 if (temp2)
27985 delete arg2;
27986 }
27987 return resultobj;
27988 fail:
27989 {
27990 if (temp2)
27991 delete arg2;
27992 }
27993 return NULL;
27994 }
27995
27996
27997 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27998 PyObject *resultobj = 0;
27999 wxPyApp *arg1 = (wxPyApp *) 0 ;
28000 wxString result;
28001 void *argp1 = 0 ;
28002 int res1 = 0 ;
28003 PyObject *swig_obj[1] ;
28004
28005 if (!args) SWIG_fail;
28006 swig_obj[0] = args;
28007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28008 if (!SWIG_IsOK(res1)) {
28009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28010 }
28011 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28012 {
28013 PyThreadState* __tstate = wxPyBeginAllowThreads();
28014 result = ((wxPyApp const *)arg1)->GetClassName();
28015 wxPyEndAllowThreads(__tstate);
28016 if (PyErr_Occurred()) SWIG_fail;
28017 }
28018 {
28019 #if wxUSE_UNICODE
28020 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28021 #else
28022 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28023 #endif
28024 }
28025 return resultobj;
28026 fail:
28027 return NULL;
28028 }
28029
28030
28031 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28032 PyObject *resultobj = 0;
28033 wxPyApp *arg1 = (wxPyApp *) 0 ;
28034 wxString *arg2 = 0 ;
28035 void *argp1 = 0 ;
28036 int res1 = 0 ;
28037 bool temp2 = false ;
28038 PyObject * obj0 = 0 ;
28039 PyObject * obj1 = 0 ;
28040 char * kwnames[] = {
28041 (char *) "self",(char *) "name", NULL
28042 };
28043
28044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
28045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28046 if (!SWIG_IsOK(res1)) {
28047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28048 }
28049 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28050 {
28051 arg2 = wxString_in_helper(obj1);
28052 if (arg2 == NULL) SWIG_fail;
28053 temp2 = true;
28054 }
28055 {
28056 PyThreadState* __tstate = wxPyBeginAllowThreads();
28057 (arg1)->SetClassName((wxString const &)*arg2);
28058 wxPyEndAllowThreads(__tstate);
28059 if (PyErr_Occurred()) SWIG_fail;
28060 }
28061 resultobj = SWIG_Py_Void();
28062 {
28063 if (temp2)
28064 delete arg2;
28065 }
28066 return resultobj;
28067 fail:
28068 {
28069 if (temp2)
28070 delete arg2;
28071 }
28072 return NULL;
28073 }
28074
28075
28076 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28077 PyObject *resultobj = 0;
28078 wxPyApp *arg1 = (wxPyApp *) 0 ;
28079 wxString *result = 0 ;
28080 void *argp1 = 0 ;
28081 int res1 = 0 ;
28082 PyObject *swig_obj[1] ;
28083
28084 if (!args) SWIG_fail;
28085 swig_obj[0] = args;
28086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28087 if (!SWIG_IsOK(res1)) {
28088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28089 }
28090 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28091 {
28092 PyThreadState* __tstate = wxPyBeginAllowThreads();
28093 {
28094 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
28095 result = (wxString *) &_result_ref;
28096 }
28097 wxPyEndAllowThreads(__tstate);
28098 if (PyErr_Occurred()) SWIG_fail;
28099 }
28100 {
28101 #if wxUSE_UNICODE
28102 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
28103 #else
28104 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
28105 #endif
28106 }
28107 return resultobj;
28108 fail:
28109 return NULL;
28110 }
28111
28112
28113 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28114 PyObject *resultobj = 0;
28115 wxPyApp *arg1 = (wxPyApp *) 0 ;
28116 wxString *arg2 = 0 ;
28117 void *argp1 = 0 ;
28118 int res1 = 0 ;
28119 bool temp2 = false ;
28120 PyObject * obj0 = 0 ;
28121 PyObject * obj1 = 0 ;
28122 char * kwnames[] = {
28123 (char *) "self",(char *) "name", NULL
28124 };
28125
28126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
28127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28128 if (!SWIG_IsOK(res1)) {
28129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28130 }
28131 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28132 {
28133 arg2 = wxString_in_helper(obj1);
28134 if (arg2 == NULL) SWIG_fail;
28135 temp2 = true;
28136 }
28137 {
28138 PyThreadState* __tstate = wxPyBeginAllowThreads();
28139 (arg1)->SetVendorName((wxString const &)*arg2);
28140 wxPyEndAllowThreads(__tstate);
28141 if (PyErr_Occurred()) SWIG_fail;
28142 }
28143 resultobj = SWIG_Py_Void();
28144 {
28145 if (temp2)
28146 delete arg2;
28147 }
28148 return resultobj;
28149 fail:
28150 {
28151 if (temp2)
28152 delete arg2;
28153 }
28154 return NULL;
28155 }
28156
28157
28158 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28159 PyObject *resultobj = 0;
28160 wxPyApp *arg1 = (wxPyApp *) 0 ;
28161 wxAppTraits *result = 0 ;
28162 void *argp1 = 0 ;
28163 int res1 = 0 ;
28164 PyObject *swig_obj[1] ;
28165
28166 if (!args) SWIG_fail;
28167 swig_obj[0] = args;
28168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28169 if (!SWIG_IsOK(res1)) {
28170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
28171 }
28172 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28173 {
28174 PyThreadState* __tstate = wxPyBeginAllowThreads();
28175 result = (wxAppTraits *)(arg1)->GetTraits();
28176 wxPyEndAllowThreads(__tstate);
28177 if (PyErr_Occurred()) SWIG_fail;
28178 }
28179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
28180 return resultobj;
28181 fail:
28182 return NULL;
28183 }
28184
28185
28186 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28187 PyObject *resultobj = 0;
28188 wxPyApp *arg1 = (wxPyApp *) 0 ;
28189 void *argp1 = 0 ;
28190 int res1 = 0 ;
28191 PyObject *swig_obj[1] ;
28192
28193 if (!args) SWIG_fail;
28194 swig_obj[0] = args;
28195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28196 if (!SWIG_IsOK(res1)) {
28197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28198 }
28199 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28200 {
28201 PyThreadState* __tstate = wxPyBeginAllowThreads();
28202 (arg1)->ProcessPendingEvents();
28203 wxPyEndAllowThreads(__tstate);
28204 if (PyErr_Occurred()) SWIG_fail;
28205 }
28206 resultobj = SWIG_Py_Void();
28207 return resultobj;
28208 fail:
28209 return NULL;
28210 }
28211
28212
28213 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28214 PyObject *resultobj = 0;
28215 wxPyApp *arg1 = (wxPyApp *) 0 ;
28216 bool arg2 = (bool) false ;
28217 bool result;
28218 void *argp1 = 0 ;
28219 int res1 = 0 ;
28220 bool val2 ;
28221 int ecode2 = 0 ;
28222 PyObject * obj0 = 0 ;
28223 PyObject * obj1 = 0 ;
28224 char * kwnames[] = {
28225 (char *) "self",(char *) "onlyIfNeeded", NULL
28226 };
28227
28228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
28229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28230 if (!SWIG_IsOK(res1)) {
28231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
28232 }
28233 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28234 if (obj1) {
28235 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28236 if (!SWIG_IsOK(ecode2)) {
28237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
28238 }
28239 arg2 = static_cast< bool >(val2);
28240 }
28241 {
28242 PyThreadState* __tstate = wxPyBeginAllowThreads();
28243 result = (bool)(arg1)->Yield(arg2);
28244 wxPyEndAllowThreads(__tstate);
28245 if (PyErr_Occurred()) SWIG_fail;
28246 }
28247 {
28248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28249 }
28250 return resultobj;
28251 fail:
28252 return NULL;
28253 }
28254
28255
28256 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28257 PyObject *resultobj = 0;
28258 wxPyApp *arg1 = (wxPyApp *) 0 ;
28259 void *argp1 = 0 ;
28260 int res1 = 0 ;
28261 PyObject *swig_obj[1] ;
28262
28263 if (!args) SWIG_fail;
28264 swig_obj[0] = args;
28265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28266 if (!SWIG_IsOK(res1)) {
28267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28268 }
28269 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28270 {
28271 PyThreadState* __tstate = wxPyBeginAllowThreads();
28272 (arg1)->WakeUpIdle();
28273 wxPyEndAllowThreads(__tstate);
28274 if (PyErr_Occurred()) SWIG_fail;
28275 }
28276 resultobj = SWIG_Py_Void();
28277 return resultobj;
28278 fail:
28279 return NULL;
28280 }
28281
28282
28283 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28284 PyObject *resultobj = 0;
28285 bool result;
28286
28287 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
28288 {
28289 PyThreadState* __tstate = wxPyBeginAllowThreads();
28290 result = (bool)wxPyApp::IsMainLoopRunning();
28291 wxPyEndAllowThreads(__tstate);
28292 if (PyErr_Occurred()) SWIG_fail;
28293 }
28294 {
28295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28296 }
28297 return resultobj;
28298 fail:
28299 return NULL;
28300 }
28301
28302
28303 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28304 PyObject *resultobj = 0;
28305 wxPyApp *arg1 = (wxPyApp *) 0 ;
28306 int result;
28307 void *argp1 = 0 ;
28308 int res1 = 0 ;
28309 PyObject *swig_obj[1] ;
28310
28311 if (!args) SWIG_fail;
28312 swig_obj[0] = args;
28313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28314 if (!SWIG_IsOK(res1)) {
28315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28316 }
28317 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28318 {
28319 PyThreadState* __tstate = wxPyBeginAllowThreads();
28320 result = (int)(arg1)->MainLoop();
28321 wxPyEndAllowThreads(__tstate);
28322 if (PyErr_Occurred()) SWIG_fail;
28323 }
28324 resultobj = SWIG_From_int(static_cast< int >(result));
28325 return resultobj;
28326 fail:
28327 return NULL;
28328 }
28329
28330
28331 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28332 PyObject *resultobj = 0;
28333 wxPyApp *arg1 = (wxPyApp *) 0 ;
28334 void *argp1 = 0 ;
28335 int res1 = 0 ;
28336 PyObject *swig_obj[1] ;
28337
28338 if (!args) SWIG_fail;
28339 swig_obj[0] = args;
28340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28341 if (!SWIG_IsOK(res1)) {
28342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
28343 }
28344 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28345 {
28346 PyThreadState* __tstate = wxPyBeginAllowThreads();
28347 (arg1)->Exit();
28348 wxPyEndAllowThreads(__tstate);
28349 if (PyErr_Occurred()) SWIG_fail;
28350 }
28351 resultobj = SWIG_Py_Void();
28352 return resultobj;
28353 fail:
28354 return NULL;
28355 }
28356
28357
28358 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28359 PyObject *resultobj = 0;
28360 wxPyApp *arg1 = (wxPyApp *) 0 ;
28361 wxLayoutDirection result;
28362 void *argp1 = 0 ;
28363 int res1 = 0 ;
28364 PyObject *swig_obj[1] ;
28365
28366 if (!args) SWIG_fail;
28367 swig_obj[0] = args;
28368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28369 if (!SWIG_IsOK(res1)) {
28370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28371 }
28372 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28373 {
28374 PyThreadState* __tstate = wxPyBeginAllowThreads();
28375 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
28376 wxPyEndAllowThreads(__tstate);
28377 if (PyErr_Occurred()) SWIG_fail;
28378 }
28379 resultobj = SWIG_From_int(static_cast< int >(result));
28380 return resultobj;
28381 fail:
28382 return NULL;
28383 }
28384
28385
28386 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28387 PyObject *resultobj = 0;
28388 wxPyApp *arg1 = (wxPyApp *) 0 ;
28389 void *argp1 = 0 ;
28390 int res1 = 0 ;
28391 PyObject *swig_obj[1] ;
28392
28393 if (!args) SWIG_fail;
28394 swig_obj[0] = args;
28395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28396 if (!SWIG_IsOK(res1)) {
28397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28398 }
28399 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28400 {
28401 PyThreadState* __tstate = wxPyBeginAllowThreads();
28402 (arg1)->ExitMainLoop();
28403 wxPyEndAllowThreads(__tstate);
28404 if (PyErr_Occurred()) SWIG_fail;
28405 }
28406 resultobj = SWIG_Py_Void();
28407 return resultobj;
28408 fail:
28409 return NULL;
28410 }
28411
28412
28413 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28414 PyObject *resultobj = 0;
28415 wxPyApp *arg1 = (wxPyApp *) 0 ;
28416 bool result;
28417 void *argp1 = 0 ;
28418 int res1 = 0 ;
28419 PyObject *swig_obj[1] ;
28420
28421 if (!args) SWIG_fail;
28422 swig_obj[0] = args;
28423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28424 if (!SWIG_IsOK(res1)) {
28425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
28426 }
28427 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28428 {
28429 PyThreadState* __tstate = wxPyBeginAllowThreads();
28430 result = (bool)(arg1)->Pending();
28431 wxPyEndAllowThreads(__tstate);
28432 if (PyErr_Occurred()) SWIG_fail;
28433 }
28434 {
28435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28436 }
28437 return resultobj;
28438 fail:
28439 return NULL;
28440 }
28441
28442
28443 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28444 PyObject *resultobj = 0;
28445 wxPyApp *arg1 = (wxPyApp *) 0 ;
28446 bool result;
28447 void *argp1 = 0 ;
28448 int res1 = 0 ;
28449 PyObject *swig_obj[1] ;
28450
28451 if (!args) SWIG_fail;
28452 swig_obj[0] = args;
28453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28454 if (!SWIG_IsOK(res1)) {
28455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
28456 }
28457 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28458 {
28459 PyThreadState* __tstate = wxPyBeginAllowThreads();
28460 result = (bool)(arg1)->Dispatch();
28461 wxPyEndAllowThreads(__tstate);
28462 if (PyErr_Occurred()) SWIG_fail;
28463 }
28464 {
28465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28466 }
28467 return resultobj;
28468 fail:
28469 return NULL;
28470 }
28471
28472
28473 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28474 PyObject *resultobj = 0;
28475 wxPyApp *arg1 = (wxPyApp *) 0 ;
28476 bool result;
28477 void *argp1 = 0 ;
28478 int res1 = 0 ;
28479 PyObject *swig_obj[1] ;
28480
28481 if (!args) SWIG_fail;
28482 swig_obj[0] = args;
28483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28484 if (!SWIG_IsOK(res1)) {
28485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28486 }
28487 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28488 {
28489 PyThreadState* __tstate = wxPyBeginAllowThreads();
28490 result = (bool)(arg1)->ProcessIdle();
28491 wxPyEndAllowThreads(__tstate);
28492 if (PyErr_Occurred()) SWIG_fail;
28493 }
28494 {
28495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28496 }
28497 return resultobj;
28498 fail:
28499 return NULL;
28500 }
28501
28502
28503 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28504 PyObject *resultobj = 0;
28505 wxPyApp *arg1 = (wxPyApp *) 0 ;
28506 wxWindow *arg2 = (wxWindow *) 0 ;
28507 wxIdleEvent *arg3 = 0 ;
28508 bool result;
28509 void *argp1 = 0 ;
28510 int res1 = 0 ;
28511 void *argp2 = 0 ;
28512 int res2 = 0 ;
28513 void *argp3 = 0 ;
28514 int res3 = 0 ;
28515 PyObject * obj0 = 0 ;
28516 PyObject * obj1 = 0 ;
28517 PyObject * obj2 = 0 ;
28518 char * kwnames[] = {
28519 (char *) "self",(char *) "win",(char *) "event", NULL
28520 };
28521
28522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28524 if (!SWIG_IsOK(res1)) {
28525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28526 }
28527 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28528 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28529 if (!SWIG_IsOK(res2)) {
28530 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
28531 }
28532 arg2 = reinterpret_cast< wxWindow * >(argp2);
28533 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
28534 if (!SWIG_IsOK(res3)) {
28535 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28536 }
28537 if (!argp3) {
28538 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28539 }
28540 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
28541 {
28542 PyThreadState* __tstate = wxPyBeginAllowThreads();
28543 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
28544 wxPyEndAllowThreads(__tstate);
28545 if (PyErr_Occurred()) SWIG_fail;
28546 }
28547 {
28548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28549 }
28550 return resultobj;
28551 fail:
28552 return NULL;
28553 }
28554
28555
28556 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28557 PyObject *resultobj = 0;
28558 wxPyApp *arg1 = (wxPyApp *) 0 ;
28559 bool result;
28560 void *argp1 = 0 ;
28561 int res1 = 0 ;
28562 PyObject *swig_obj[1] ;
28563
28564 if (!args) SWIG_fail;
28565 swig_obj[0] = args;
28566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28567 if (!SWIG_IsOK(res1)) {
28568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28569 }
28570 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28571 {
28572 PyThreadState* __tstate = wxPyBeginAllowThreads();
28573 result = (bool)((wxPyApp const *)arg1)->IsActive();
28574 wxPyEndAllowThreads(__tstate);
28575 if (PyErr_Occurred()) SWIG_fail;
28576 }
28577 {
28578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28579 }
28580 return resultobj;
28581 fail:
28582 return NULL;
28583 }
28584
28585
28586 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28587 PyObject *resultobj = 0;
28588 wxPyApp *arg1 = (wxPyApp *) 0 ;
28589 wxWindow *arg2 = (wxWindow *) 0 ;
28590 void *argp1 = 0 ;
28591 int res1 = 0 ;
28592 void *argp2 = 0 ;
28593 int res2 = 0 ;
28594 PyObject * obj0 = 0 ;
28595 PyObject * obj1 = 0 ;
28596 char * kwnames[] = {
28597 (char *) "self",(char *) "win", NULL
28598 };
28599
28600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28602 if (!SWIG_IsOK(res1)) {
28603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28604 }
28605 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28606 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28607 if (!SWIG_IsOK(res2)) {
28608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28609 }
28610 arg2 = reinterpret_cast< wxWindow * >(argp2);
28611 {
28612 PyThreadState* __tstate = wxPyBeginAllowThreads();
28613 (arg1)->SetTopWindow(arg2);
28614 wxPyEndAllowThreads(__tstate);
28615 if (PyErr_Occurred()) SWIG_fail;
28616 }
28617 resultobj = SWIG_Py_Void();
28618 return resultobj;
28619 fail:
28620 return NULL;
28621 }
28622
28623
28624 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28625 PyObject *resultobj = 0;
28626 wxPyApp *arg1 = (wxPyApp *) 0 ;
28627 wxWindow *result = 0 ;
28628 void *argp1 = 0 ;
28629 int res1 = 0 ;
28630 PyObject *swig_obj[1] ;
28631
28632 if (!args) SWIG_fail;
28633 swig_obj[0] = args;
28634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28635 if (!SWIG_IsOK(res1)) {
28636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28637 }
28638 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28639 {
28640 PyThreadState* __tstate = wxPyBeginAllowThreads();
28641 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28642 wxPyEndAllowThreads(__tstate);
28643 if (PyErr_Occurred()) SWIG_fail;
28644 }
28645 {
28646 resultobj = wxPyMake_wxObject(result, (bool)0);
28647 }
28648 return resultobj;
28649 fail:
28650 return NULL;
28651 }
28652
28653
28654 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28655 PyObject *resultobj = 0;
28656 wxPyApp *arg1 = (wxPyApp *) 0 ;
28657 bool arg2 ;
28658 void *argp1 = 0 ;
28659 int res1 = 0 ;
28660 bool val2 ;
28661 int ecode2 = 0 ;
28662 PyObject * obj0 = 0 ;
28663 PyObject * obj1 = 0 ;
28664 char * kwnames[] = {
28665 (char *) "self",(char *) "flag", NULL
28666 };
28667
28668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28670 if (!SWIG_IsOK(res1)) {
28671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28672 }
28673 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28674 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28675 if (!SWIG_IsOK(ecode2)) {
28676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28677 }
28678 arg2 = static_cast< bool >(val2);
28679 {
28680 PyThreadState* __tstate = wxPyBeginAllowThreads();
28681 (arg1)->SetExitOnFrameDelete(arg2);
28682 wxPyEndAllowThreads(__tstate);
28683 if (PyErr_Occurred()) SWIG_fail;
28684 }
28685 resultobj = SWIG_Py_Void();
28686 return resultobj;
28687 fail:
28688 return NULL;
28689 }
28690
28691
28692 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28693 PyObject *resultobj = 0;
28694 wxPyApp *arg1 = (wxPyApp *) 0 ;
28695 bool result;
28696 void *argp1 = 0 ;
28697 int res1 = 0 ;
28698 PyObject *swig_obj[1] ;
28699
28700 if (!args) SWIG_fail;
28701 swig_obj[0] = args;
28702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28703 if (!SWIG_IsOK(res1)) {
28704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28705 }
28706 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28707 {
28708 PyThreadState* __tstate = wxPyBeginAllowThreads();
28709 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28710 wxPyEndAllowThreads(__tstate);
28711 if (PyErr_Occurred()) SWIG_fail;
28712 }
28713 {
28714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28715 }
28716 return resultobj;
28717 fail:
28718 return NULL;
28719 }
28720
28721
28722 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28723 PyObject *resultobj = 0;
28724 wxPyApp *arg1 = (wxPyApp *) 0 ;
28725 bool arg2 ;
28726 void *argp1 = 0 ;
28727 int res1 = 0 ;
28728 bool val2 ;
28729 int ecode2 = 0 ;
28730 PyObject * obj0 = 0 ;
28731 PyObject * obj1 = 0 ;
28732 char * kwnames[] = {
28733 (char *) "self",(char *) "flag", NULL
28734 };
28735
28736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28738 if (!SWIG_IsOK(res1)) {
28739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28740 }
28741 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28742 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28743 if (!SWIG_IsOK(ecode2)) {
28744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28745 }
28746 arg2 = static_cast< bool >(val2);
28747 {
28748 PyThreadState* __tstate = wxPyBeginAllowThreads();
28749 (arg1)->SetUseBestVisual(arg2);
28750 wxPyEndAllowThreads(__tstate);
28751 if (PyErr_Occurred()) SWIG_fail;
28752 }
28753 resultobj = SWIG_Py_Void();
28754 return resultobj;
28755 fail:
28756 return NULL;
28757 }
28758
28759
28760 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28761 PyObject *resultobj = 0;
28762 wxPyApp *arg1 = (wxPyApp *) 0 ;
28763 bool result;
28764 void *argp1 = 0 ;
28765 int res1 = 0 ;
28766 PyObject *swig_obj[1] ;
28767
28768 if (!args) SWIG_fail;
28769 swig_obj[0] = args;
28770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28771 if (!SWIG_IsOK(res1)) {
28772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28773 }
28774 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28775 {
28776 PyThreadState* __tstate = wxPyBeginAllowThreads();
28777 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28778 wxPyEndAllowThreads(__tstate);
28779 if (PyErr_Occurred()) SWIG_fail;
28780 }
28781 {
28782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28783 }
28784 return resultobj;
28785 fail:
28786 return NULL;
28787 }
28788
28789
28790 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28791 PyObject *resultobj = 0;
28792 wxPyApp *arg1 = (wxPyApp *) 0 ;
28793 int arg2 ;
28794 void *argp1 = 0 ;
28795 int res1 = 0 ;
28796 int val2 ;
28797 int ecode2 = 0 ;
28798 PyObject * obj0 = 0 ;
28799 PyObject * obj1 = 0 ;
28800 char * kwnames[] = {
28801 (char *) "self",(char *) "mode", NULL
28802 };
28803
28804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28806 if (!SWIG_IsOK(res1)) {
28807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28808 }
28809 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28810 ecode2 = SWIG_AsVal_int(obj1, &val2);
28811 if (!SWIG_IsOK(ecode2)) {
28812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28813 }
28814 arg2 = static_cast< int >(val2);
28815 {
28816 PyThreadState* __tstate = wxPyBeginAllowThreads();
28817 (arg1)->SetPrintMode(arg2);
28818 wxPyEndAllowThreads(__tstate);
28819 if (PyErr_Occurred()) SWIG_fail;
28820 }
28821 resultobj = SWIG_Py_Void();
28822 return resultobj;
28823 fail:
28824 return NULL;
28825 }
28826
28827
28828 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28829 PyObject *resultobj = 0;
28830 wxPyApp *arg1 = (wxPyApp *) 0 ;
28831 int result;
28832 void *argp1 = 0 ;
28833 int res1 = 0 ;
28834 PyObject *swig_obj[1] ;
28835
28836 if (!args) SWIG_fail;
28837 swig_obj[0] = args;
28838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28839 if (!SWIG_IsOK(res1)) {
28840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28841 }
28842 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28843 {
28844 PyThreadState* __tstate = wxPyBeginAllowThreads();
28845 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28846 wxPyEndAllowThreads(__tstate);
28847 if (PyErr_Occurred()) SWIG_fail;
28848 }
28849 resultobj = SWIG_From_int(static_cast< int >(result));
28850 return resultobj;
28851 fail:
28852 return NULL;
28853 }
28854
28855
28856 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28857 PyObject *resultobj = 0;
28858 wxPyApp *arg1 = (wxPyApp *) 0 ;
28859 int arg2 ;
28860 void *argp1 = 0 ;
28861 int res1 = 0 ;
28862 int val2 ;
28863 int ecode2 = 0 ;
28864 PyObject * obj0 = 0 ;
28865 PyObject * obj1 = 0 ;
28866 char * kwnames[] = {
28867 (char *) "self",(char *) "mode", NULL
28868 };
28869
28870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28872 if (!SWIG_IsOK(res1)) {
28873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28874 }
28875 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28876 ecode2 = SWIG_AsVal_int(obj1, &val2);
28877 if (!SWIG_IsOK(ecode2)) {
28878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28879 }
28880 arg2 = static_cast< int >(val2);
28881 {
28882 PyThreadState* __tstate = wxPyBeginAllowThreads();
28883 (arg1)->SetAssertMode(arg2);
28884 wxPyEndAllowThreads(__tstate);
28885 if (PyErr_Occurred()) SWIG_fail;
28886 }
28887 resultobj = SWIG_Py_Void();
28888 return resultobj;
28889 fail:
28890 return NULL;
28891 }
28892
28893
28894 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28895 PyObject *resultobj = 0;
28896 wxPyApp *arg1 = (wxPyApp *) 0 ;
28897 int result;
28898 void *argp1 = 0 ;
28899 int res1 = 0 ;
28900 PyObject *swig_obj[1] ;
28901
28902 if (!args) SWIG_fail;
28903 swig_obj[0] = args;
28904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28905 if (!SWIG_IsOK(res1)) {
28906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28907 }
28908 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 result = (int)(arg1)->GetAssertMode();
28912 wxPyEndAllowThreads(__tstate);
28913 if (PyErr_Occurred()) SWIG_fail;
28914 }
28915 resultobj = SWIG_From_int(static_cast< int >(result));
28916 return resultobj;
28917 fail:
28918 return NULL;
28919 }
28920
28921
28922 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28923 PyObject *resultobj = 0;
28924 bool result;
28925
28926 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28927 {
28928 PyThreadState* __tstate = wxPyBeginAllowThreads();
28929 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28930 wxPyEndAllowThreads(__tstate);
28931 if (PyErr_Occurred()) SWIG_fail;
28932 }
28933 {
28934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28935 }
28936 return resultobj;
28937 fail:
28938 return NULL;
28939 }
28940
28941
28942 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28943 PyObject *resultobj = 0;
28944 long result;
28945
28946 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28947 {
28948 PyThreadState* __tstate = wxPyBeginAllowThreads();
28949 result = (long)wxPyApp::GetMacAboutMenuItemId();
28950 wxPyEndAllowThreads(__tstate);
28951 if (PyErr_Occurred()) SWIG_fail;
28952 }
28953 resultobj = SWIG_From_long(static_cast< long >(result));
28954 return resultobj;
28955 fail:
28956 return NULL;
28957 }
28958
28959
28960 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28961 PyObject *resultobj = 0;
28962 long result;
28963
28964 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28965 {
28966 PyThreadState* __tstate = wxPyBeginAllowThreads();
28967 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28968 wxPyEndAllowThreads(__tstate);
28969 if (PyErr_Occurred()) SWIG_fail;
28970 }
28971 resultobj = SWIG_From_long(static_cast< long >(result));
28972 return resultobj;
28973 fail:
28974 return NULL;
28975 }
28976
28977
28978 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28979 PyObject *resultobj = 0;
28980 long result;
28981
28982 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28983 {
28984 PyThreadState* __tstate = wxPyBeginAllowThreads();
28985 result = (long)wxPyApp::GetMacExitMenuItemId();
28986 wxPyEndAllowThreads(__tstate);
28987 if (PyErr_Occurred()) SWIG_fail;
28988 }
28989 resultobj = SWIG_From_long(static_cast< long >(result));
28990 return resultobj;
28991 fail:
28992 return NULL;
28993 }
28994
28995
28996 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28997 PyObject *resultobj = 0;
28998 wxString result;
28999
29000 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
29001 {
29002 PyThreadState* __tstate = wxPyBeginAllowThreads();
29003 result = wxPyApp::GetMacHelpMenuTitleName();
29004 wxPyEndAllowThreads(__tstate);
29005 if (PyErr_Occurred()) SWIG_fail;
29006 }
29007 {
29008 #if wxUSE_UNICODE
29009 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29010 #else
29011 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29012 #endif
29013 }
29014 return resultobj;
29015 fail:
29016 return NULL;
29017 }
29018
29019
29020 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29021 PyObject *resultobj = 0;
29022 bool arg1 ;
29023 bool val1 ;
29024 int ecode1 = 0 ;
29025 PyObject * obj0 = 0 ;
29026 char * kwnames[] = {
29027 (char *) "val", NULL
29028 };
29029
29030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
29031 ecode1 = SWIG_AsVal_bool(obj0, &val1);
29032 if (!SWIG_IsOK(ecode1)) {
29033 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
29034 }
29035 arg1 = static_cast< bool >(val1);
29036 {
29037 PyThreadState* __tstate = wxPyBeginAllowThreads();
29038 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
29039 wxPyEndAllowThreads(__tstate);
29040 if (PyErr_Occurred()) SWIG_fail;
29041 }
29042 resultobj = SWIG_Py_Void();
29043 return resultobj;
29044 fail:
29045 return NULL;
29046 }
29047
29048
29049 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29050 PyObject *resultobj = 0;
29051 long arg1 ;
29052 long val1 ;
29053 int ecode1 = 0 ;
29054 PyObject * obj0 = 0 ;
29055 char * kwnames[] = {
29056 (char *) "val", NULL
29057 };
29058
29059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
29060 ecode1 = SWIG_AsVal_long(obj0, &val1);
29061 if (!SWIG_IsOK(ecode1)) {
29062 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
29063 }
29064 arg1 = static_cast< long >(val1);
29065 {
29066 PyThreadState* __tstate = wxPyBeginAllowThreads();
29067 wxPyApp::SetMacAboutMenuItemId(arg1);
29068 wxPyEndAllowThreads(__tstate);
29069 if (PyErr_Occurred()) SWIG_fail;
29070 }
29071 resultobj = SWIG_Py_Void();
29072 return resultobj;
29073 fail:
29074 return NULL;
29075 }
29076
29077
29078 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29079 PyObject *resultobj = 0;
29080 long arg1 ;
29081 long val1 ;
29082 int ecode1 = 0 ;
29083 PyObject * obj0 = 0 ;
29084 char * kwnames[] = {
29085 (char *) "val", NULL
29086 };
29087
29088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
29089 ecode1 = SWIG_AsVal_long(obj0, &val1);
29090 if (!SWIG_IsOK(ecode1)) {
29091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
29092 }
29093 arg1 = static_cast< long >(val1);
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 wxPyApp::SetMacPreferencesMenuItemId(arg1);
29097 wxPyEndAllowThreads(__tstate);
29098 if (PyErr_Occurred()) SWIG_fail;
29099 }
29100 resultobj = SWIG_Py_Void();
29101 return resultobj;
29102 fail:
29103 return NULL;
29104 }
29105
29106
29107 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29108 PyObject *resultobj = 0;
29109 long arg1 ;
29110 long val1 ;
29111 int ecode1 = 0 ;
29112 PyObject * obj0 = 0 ;
29113 char * kwnames[] = {
29114 (char *) "val", NULL
29115 };
29116
29117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
29118 ecode1 = SWIG_AsVal_long(obj0, &val1);
29119 if (!SWIG_IsOK(ecode1)) {
29120 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
29121 }
29122 arg1 = static_cast< long >(val1);
29123 {
29124 PyThreadState* __tstate = wxPyBeginAllowThreads();
29125 wxPyApp::SetMacExitMenuItemId(arg1);
29126 wxPyEndAllowThreads(__tstate);
29127 if (PyErr_Occurred()) SWIG_fail;
29128 }
29129 resultobj = SWIG_Py_Void();
29130 return resultobj;
29131 fail:
29132 return NULL;
29133 }
29134
29135
29136 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29137 PyObject *resultobj = 0;
29138 wxString *arg1 = 0 ;
29139 bool temp1 = false ;
29140 PyObject * obj0 = 0 ;
29141 char * kwnames[] = {
29142 (char *) "val", NULL
29143 };
29144
29145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
29146 {
29147 arg1 = wxString_in_helper(obj0);
29148 if (arg1 == NULL) SWIG_fail;
29149 temp1 = true;
29150 }
29151 {
29152 PyThreadState* __tstate = wxPyBeginAllowThreads();
29153 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
29154 wxPyEndAllowThreads(__tstate);
29155 if (PyErr_Occurred()) SWIG_fail;
29156 }
29157 resultobj = SWIG_Py_Void();
29158 {
29159 if (temp1)
29160 delete arg1;
29161 }
29162 return resultobj;
29163 fail:
29164 {
29165 if (temp1)
29166 delete arg1;
29167 }
29168 return NULL;
29169 }
29170
29171
29172 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29173 PyObject *resultobj = 0;
29174 wxPyApp *arg1 = (wxPyApp *) 0 ;
29175 void *argp1 = 0 ;
29176 int res1 = 0 ;
29177 PyObject *swig_obj[1] ;
29178
29179 if (!args) SWIG_fail;
29180 swig_obj[0] = args;
29181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29182 if (!SWIG_IsOK(res1)) {
29183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29184 }
29185 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29186 {
29187 PyThreadState* __tstate = wxPyBeginAllowThreads();
29188 (arg1)->_BootstrapApp();
29189 wxPyEndAllowThreads(__tstate);
29190 if (PyErr_Occurred()) SWIG_fail;
29191 }
29192 resultobj = SWIG_Py_Void();
29193 return resultobj;
29194 fail:
29195 return NULL;
29196 }
29197
29198
29199 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29200 PyObject *resultobj = 0;
29201 int result;
29202
29203 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
29204 {
29205 PyThreadState* __tstate = wxPyBeginAllowThreads();
29206 result = (int)wxPyApp_GetComCtl32Version();
29207 wxPyEndAllowThreads(__tstate);
29208 if (PyErr_Occurred()) SWIG_fail;
29209 }
29210 resultobj = SWIG_From_int(static_cast< int >(result));
29211 return resultobj;
29212 fail:
29213 return NULL;
29214 }
29215
29216
29217 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29218 PyObject *resultobj = 0;
29219 bool result;
29220
29221 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
29222 {
29223 PyThreadState* __tstate = wxPyBeginAllowThreads();
29224 result = (bool)wxPyApp_IsDisplayAvailable();
29225 wxPyEndAllowThreads(__tstate);
29226 if (PyErr_Occurred()) SWIG_fail;
29227 }
29228 {
29229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29230 }
29231 return resultobj;
29232 fail:
29233 return NULL;
29234 }
29235
29236
29237 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29238 PyObject *obj;
29239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29240 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
29241 return SWIG_Py_Void();
29242 }
29243
29244 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29245 return SWIG_Python_InitShadowInstance(args);
29246 }
29247
29248 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29249 PyObject *resultobj = 0;
29250
29251 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
29252 {
29253 PyThreadState* __tstate = wxPyBeginAllowThreads();
29254 wxExit();
29255 wxPyEndAllowThreads(__tstate);
29256 if (PyErr_Occurred()) SWIG_fail;
29257 }
29258 resultobj = SWIG_Py_Void();
29259 return resultobj;
29260 fail:
29261 return NULL;
29262 }
29263
29264
29265 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29266 PyObject *resultobj = 0;
29267 bool result;
29268
29269 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
29270 {
29271 PyThreadState* __tstate = wxPyBeginAllowThreads();
29272 result = (bool)wxYield();
29273 wxPyEndAllowThreads(__tstate);
29274 if (PyErr_Occurred()) SWIG_fail;
29275 }
29276 {
29277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29278 }
29279 return resultobj;
29280 fail:
29281 return NULL;
29282 }
29283
29284
29285 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29286 PyObject *resultobj = 0;
29287 bool result;
29288
29289 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
29290 {
29291 PyThreadState* __tstate = wxPyBeginAllowThreads();
29292 result = (bool)wxYieldIfNeeded();
29293 wxPyEndAllowThreads(__tstate);
29294 if (PyErr_Occurred()) SWIG_fail;
29295 }
29296 {
29297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29298 }
29299 return resultobj;
29300 fail:
29301 return NULL;
29302 }
29303
29304
29305 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29306 PyObject *resultobj = 0;
29307 wxWindow *arg1 = (wxWindow *) NULL ;
29308 bool arg2 = (bool) false ;
29309 bool result;
29310 void *argp1 = 0 ;
29311 int res1 = 0 ;
29312 bool val2 ;
29313 int ecode2 = 0 ;
29314 PyObject * obj0 = 0 ;
29315 PyObject * obj1 = 0 ;
29316 char * kwnames[] = {
29317 (char *) "win",(char *) "onlyIfNeeded", NULL
29318 };
29319
29320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
29321 if (obj0) {
29322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29323 if (!SWIG_IsOK(res1)) {
29324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
29325 }
29326 arg1 = reinterpret_cast< wxWindow * >(argp1);
29327 }
29328 if (obj1) {
29329 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29330 if (!SWIG_IsOK(ecode2)) {
29331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
29332 }
29333 arg2 = static_cast< bool >(val2);
29334 }
29335 {
29336 PyThreadState* __tstate = wxPyBeginAllowThreads();
29337 result = (bool)wxSafeYield(arg1,arg2);
29338 wxPyEndAllowThreads(__tstate);
29339 if (PyErr_Occurred()) SWIG_fail;
29340 }
29341 {
29342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29343 }
29344 return resultobj;
29345 fail:
29346 return NULL;
29347 }
29348
29349
29350 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29351 PyObject *resultobj = 0;
29352
29353 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
29354 {
29355 PyThreadState* __tstate = wxPyBeginAllowThreads();
29356 wxWakeUpIdle();
29357 wxPyEndAllowThreads(__tstate);
29358 if (PyErr_Occurred()) SWIG_fail;
29359 }
29360 resultobj = SWIG_Py_Void();
29361 return resultobj;
29362 fail:
29363 return NULL;
29364 }
29365
29366
29367 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29368 PyObject *resultobj = 0;
29369 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
29370 wxEvent *arg2 = 0 ;
29371 void *argp1 = 0 ;
29372 int res1 = 0 ;
29373 void *argp2 = 0 ;
29374 int res2 = 0 ;
29375 PyObject * obj0 = 0 ;
29376 PyObject * obj1 = 0 ;
29377 char * kwnames[] = {
29378 (char *) "dest",(char *) "event", NULL
29379 };
29380
29381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
29383 if (!SWIG_IsOK(res1)) {
29384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
29385 }
29386 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
29387 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
29388 if (!SWIG_IsOK(res2)) {
29389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29390 }
29391 if (!argp2) {
29392 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29393 }
29394 arg2 = reinterpret_cast< wxEvent * >(argp2);
29395 {
29396 PyThreadState* __tstate = wxPyBeginAllowThreads();
29397 wxPostEvent(arg1,*arg2);
29398 wxPyEndAllowThreads(__tstate);
29399 if (PyErr_Occurred()) SWIG_fail;
29400 }
29401 resultobj = SWIG_Py_Void();
29402 return resultobj;
29403 fail:
29404 return NULL;
29405 }
29406
29407
29408 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29409 PyObject *resultobj = 0;
29410
29411 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
29412 {
29413 PyThreadState* __tstate = wxPyBeginAllowThreads();
29414 wxApp_CleanUp();
29415 wxPyEndAllowThreads(__tstate);
29416 if (PyErr_Occurred()) SWIG_fail;
29417 }
29418 resultobj = SWIG_Py_Void();
29419 return resultobj;
29420 fail:
29421 return NULL;
29422 }
29423
29424
29425 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29426 PyObject *resultobj = 0;
29427 wxPyApp *result = 0 ;
29428
29429 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 result = (wxPyApp *)wxPyGetApp();
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 {
29437 resultobj = wxPyMake_wxObject(result, 0);
29438 }
29439 return resultobj;
29440 fail:
29441 return NULL;
29442 }
29443
29444
29445 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29446 PyObject *resultobj = 0;
29447 char *arg1 = (char *) 0 ;
29448 int res1 ;
29449 char *buf1 = 0 ;
29450 int alloc1 = 0 ;
29451 PyObject * obj0 = 0 ;
29452 char * kwnames[] = {
29453 (char *) "encoding", NULL
29454 };
29455
29456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
29457 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
29458 if (!SWIG_IsOK(res1)) {
29459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
29460 }
29461 arg1 = buf1;
29462 {
29463 PyThreadState* __tstate = wxPyBeginAllowThreads();
29464 wxSetDefaultPyEncoding((char const *)arg1);
29465 wxPyEndAllowThreads(__tstate);
29466 if (PyErr_Occurred()) SWIG_fail;
29467 }
29468 resultobj = SWIG_Py_Void();
29469 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29470 return resultobj;
29471 fail:
29472 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29473 return NULL;
29474 }
29475
29476
29477 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29478 PyObject *resultobj = 0;
29479 char *result = 0 ;
29480
29481 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
29482 {
29483 PyThreadState* __tstate = wxPyBeginAllowThreads();
29484 result = (char *)wxGetDefaultPyEncoding();
29485 wxPyEndAllowThreads(__tstate);
29486 if (PyErr_Occurred()) SWIG_fail;
29487 }
29488 resultobj = SWIG_FromCharPtr(result);
29489 return resultobj;
29490 fail:
29491 return NULL;
29492 }
29493
29494
29495 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29496 PyObject *resultobj = 0;
29497 wxEventLoop *result = 0 ;
29498
29499 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
29500 {
29501 PyThreadState* __tstate = wxPyBeginAllowThreads();
29502 result = (wxEventLoop *)new wxEventLoop();
29503 wxPyEndAllowThreads(__tstate);
29504 if (PyErr_Occurred()) SWIG_fail;
29505 }
29506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
29507 return resultobj;
29508 fail:
29509 return NULL;
29510 }
29511
29512
29513 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29514 PyObject *resultobj = 0;
29515 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29516 void *argp1 = 0 ;
29517 int res1 = 0 ;
29518 PyObject *swig_obj[1] ;
29519
29520 if (!args) SWIG_fail;
29521 swig_obj[0] = args;
29522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
29523 if (!SWIG_IsOK(res1)) {
29524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29525 }
29526 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29527 {
29528 PyThreadState* __tstate = wxPyBeginAllowThreads();
29529 delete arg1;
29530
29531 wxPyEndAllowThreads(__tstate);
29532 if (PyErr_Occurred()) SWIG_fail;
29533 }
29534 resultobj = SWIG_Py_Void();
29535 return resultobj;
29536 fail:
29537 return NULL;
29538 }
29539
29540
29541 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29542 PyObject *resultobj = 0;
29543 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29544 int result;
29545 void *argp1 = 0 ;
29546 int res1 = 0 ;
29547 PyObject *swig_obj[1] ;
29548
29549 if (!args) SWIG_fail;
29550 swig_obj[0] = args;
29551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29552 if (!SWIG_IsOK(res1)) {
29553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29554 }
29555 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29556 {
29557 PyThreadState* __tstate = wxPyBeginAllowThreads();
29558 result = (int)(arg1)->Run();
29559 wxPyEndAllowThreads(__tstate);
29560 if (PyErr_Occurred()) SWIG_fail;
29561 }
29562 resultobj = SWIG_From_int(static_cast< int >(result));
29563 return resultobj;
29564 fail:
29565 return NULL;
29566 }
29567
29568
29569 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29570 PyObject *resultobj = 0;
29571 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29572 int arg2 = (int) 0 ;
29573 void *argp1 = 0 ;
29574 int res1 = 0 ;
29575 int val2 ;
29576 int ecode2 = 0 ;
29577 PyObject * obj0 = 0 ;
29578 PyObject * obj1 = 0 ;
29579 char * kwnames[] = {
29580 (char *) "self",(char *) "rc", NULL
29581 };
29582
29583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
29584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29585 if (!SWIG_IsOK(res1)) {
29586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29587 }
29588 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29589 if (obj1) {
29590 ecode2 = SWIG_AsVal_int(obj1, &val2);
29591 if (!SWIG_IsOK(ecode2)) {
29592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29593 }
29594 arg2 = static_cast< int >(val2);
29595 }
29596 {
29597 PyThreadState* __tstate = wxPyBeginAllowThreads();
29598 (arg1)->Exit(arg2);
29599 wxPyEndAllowThreads(__tstate);
29600 if (PyErr_Occurred()) SWIG_fail;
29601 }
29602 resultobj = SWIG_Py_Void();
29603 return resultobj;
29604 fail:
29605 return NULL;
29606 }
29607
29608
29609 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29610 PyObject *resultobj = 0;
29611 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29612 bool result;
29613 void *argp1 = 0 ;
29614 int res1 = 0 ;
29615 PyObject *swig_obj[1] ;
29616
29617 if (!args) SWIG_fail;
29618 swig_obj[0] = args;
29619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29620 if (!SWIG_IsOK(res1)) {
29621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29622 }
29623 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29624 {
29625 PyThreadState* __tstate = wxPyBeginAllowThreads();
29626 result = (bool)((wxEventLoop const *)arg1)->Pending();
29627 wxPyEndAllowThreads(__tstate);
29628 if (PyErr_Occurred()) SWIG_fail;
29629 }
29630 {
29631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29632 }
29633 return resultobj;
29634 fail:
29635 return NULL;
29636 }
29637
29638
29639 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29640 PyObject *resultobj = 0;
29641 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29642 bool result;
29643 void *argp1 = 0 ;
29644 int res1 = 0 ;
29645 PyObject *swig_obj[1] ;
29646
29647 if (!args) SWIG_fail;
29648 swig_obj[0] = args;
29649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29650 if (!SWIG_IsOK(res1)) {
29651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29652 }
29653 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29654 {
29655 PyThreadState* __tstate = wxPyBeginAllowThreads();
29656 result = (bool)(arg1)->Dispatch();
29657 wxPyEndAllowThreads(__tstate);
29658 if (PyErr_Occurred()) SWIG_fail;
29659 }
29660 {
29661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29662 }
29663 return resultobj;
29664 fail:
29665 return NULL;
29666 }
29667
29668
29669 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29670 PyObject *resultobj = 0;
29671 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29672 bool result;
29673 void *argp1 = 0 ;
29674 int res1 = 0 ;
29675 PyObject *swig_obj[1] ;
29676
29677 if (!args) SWIG_fail;
29678 swig_obj[0] = args;
29679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29680 if (!SWIG_IsOK(res1)) {
29681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29682 }
29683 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29684 {
29685 PyThreadState* __tstate = wxPyBeginAllowThreads();
29686 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29687 wxPyEndAllowThreads(__tstate);
29688 if (PyErr_Occurred()) SWIG_fail;
29689 }
29690 {
29691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29692 }
29693 return resultobj;
29694 fail:
29695 return NULL;
29696 }
29697
29698
29699 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29700 PyObject *resultobj = 0;
29701 wxEventLoop *result = 0 ;
29702
29703 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29704 {
29705 PyThreadState* __tstate = wxPyBeginAllowThreads();
29706 result = (wxEventLoop *)wxEventLoop::GetActive();
29707 wxPyEndAllowThreads(__tstate);
29708 if (PyErr_Occurred()) SWIG_fail;
29709 }
29710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29711 return resultobj;
29712 fail:
29713 return NULL;
29714 }
29715
29716
29717 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29718 PyObject *resultobj = 0;
29719 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29720 void *argp1 = 0 ;
29721 int res1 = 0 ;
29722 PyObject * obj0 = 0 ;
29723 char * kwnames[] = {
29724 (char *) "loop", NULL
29725 };
29726
29727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29729 if (!SWIG_IsOK(res1)) {
29730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29731 }
29732 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29733 {
29734 PyThreadState* __tstate = wxPyBeginAllowThreads();
29735 wxEventLoop::SetActive(arg1);
29736 wxPyEndAllowThreads(__tstate);
29737 if (PyErr_Occurred()) SWIG_fail;
29738 }
29739 resultobj = SWIG_Py_Void();
29740 return resultobj;
29741 fail:
29742 return NULL;
29743 }
29744
29745
29746 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29747 PyObject *obj;
29748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29749 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29750 return SWIG_Py_Void();
29751 }
29752
29753 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29754 return SWIG_Python_InitShadowInstance(args);
29755 }
29756
29757 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29758 PyObject *resultobj = 0;
29759 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29760 wxEventLoopActivator *result = 0 ;
29761 void *argp1 = 0 ;
29762 int res1 = 0 ;
29763 PyObject * obj0 = 0 ;
29764 char * kwnames[] = {
29765 (char *) "evtLoop", NULL
29766 };
29767
29768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29770 if (!SWIG_IsOK(res1)) {
29771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29772 }
29773 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29774 {
29775 PyThreadState* __tstate = wxPyBeginAllowThreads();
29776 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29777 wxPyEndAllowThreads(__tstate);
29778 if (PyErr_Occurred()) SWIG_fail;
29779 }
29780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29781 return resultobj;
29782 fail:
29783 return NULL;
29784 }
29785
29786
29787 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29788 PyObject *resultobj = 0;
29789 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29790 void *argp1 = 0 ;
29791 int res1 = 0 ;
29792 PyObject *swig_obj[1] ;
29793
29794 if (!args) SWIG_fail;
29795 swig_obj[0] = args;
29796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29797 if (!SWIG_IsOK(res1)) {
29798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29799 }
29800 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29801 {
29802 PyThreadState* __tstate = wxPyBeginAllowThreads();
29803 delete arg1;
29804
29805 wxPyEndAllowThreads(__tstate);
29806 if (PyErr_Occurred()) SWIG_fail;
29807 }
29808 resultobj = SWIG_Py_Void();
29809 return resultobj;
29810 fail:
29811 return NULL;
29812 }
29813
29814
29815 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29816 PyObject *obj;
29817 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29818 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29819 return SWIG_Py_Void();
29820 }
29821
29822 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29823 return SWIG_Python_InitShadowInstance(args);
29824 }
29825
29826 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29827 PyObject *resultobj = 0;
29828 int arg1 = (int) 0 ;
29829 int arg2 = (int) 0 ;
29830 int arg3 = (int) 0 ;
29831 wxAcceleratorEntry *result = 0 ;
29832 int val1 ;
29833 int ecode1 = 0 ;
29834 int val2 ;
29835 int ecode2 = 0 ;
29836 int val3 ;
29837 int ecode3 = 0 ;
29838 PyObject * obj0 = 0 ;
29839 PyObject * obj1 = 0 ;
29840 PyObject * obj2 = 0 ;
29841 char * kwnames[] = {
29842 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29843 };
29844
29845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29846 if (obj0) {
29847 ecode1 = SWIG_AsVal_int(obj0, &val1);
29848 if (!SWIG_IsOK(ecode1)) {
29849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29850 }
29851 arg1 = static_cast< int >(val1);
29852 }
29853 if (obj1) {
29854 ecode2 = SWIG_AsVal_int(obj1, &val2);
29855 if (!SWIG_IsOK(ecode2)) {
29856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29857 }
29858 arg2 = static_cast< int >(val2);
29859 }
29860 if (obj2) {
29861 ecode3 = SWIG_AsVal_int(obj2, &val3);
29862 if (!SWIG_IsOK(ecode3)) {
29863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29864 }
29865 arg3 = static_cast< int >(val3);
29866 }
29867 {
29868 PyThreadState* __tstate = wxPyBeginAllowThreads();
29869 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29870 wxPyEndAllowThreads(__tstate);
29871 if (PyErr_Occurred()) SWIG_fail;
29872 }
29873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29874 return resultobj;
29875 fail:
29876 return NULL;
29877 }
29878
29879
29880 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29881 PyObject *resultobj = 0;
29882 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29883 void *argp1 = 0 ;
29884 int res1 = 0 ;
29885 PyObject *swig_obj[1] ;
29886
29887 if (!args) SWIG_fail;
29888 swig_obj[0] = args;
29889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29890 if (!SWIG_IsOK(res1)) {
29891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29892 }
29893 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29894 {
29895 PyThreadState* __tstate = wxPyBeginAllowThreads();
29896 delete arg1;
29897
29898 wxPyEndAllowThreads(__tstate);
29899 if (PyErr_Occurred()) SWIG_fail;
29900 }
29901 resultobj = SWIG_Py_Void();
29902 return resultobj;
29903 fail:
29904 return NULL;
29905 }
29906
29907
29908 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29909 PyObject *resultobj = 0;
29910 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29911 int arg2 ;
29912 int arg3 ;
29913 int arg4 ;
29914 void *argp1 = 0 ;
29915 int res1 = 0 ;
29916 int val2 ;
29917 int ecode2 = 0 ;
29918 int val3 ;
29919 int ecode3 = 0 ;
29920 int val4 ;
29921 int ecode4 = 0 ;
29922 PyObject * obj0 = 0 ;
29923 PyObject * obj1 = 0 ;
29924 PyObject * obj2 = 0 ;
29925 PyObject * obj3 = 0 ;
29926 char * kwnames[] = {
29927 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29928 };
29929
29930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29932 if (!SWIG_IsOK(res1)) {
29933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29934 }
29935 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29936 ecode2 = SWIG_AsVal_int(obj1, &val2);
29937 if (!SWIG_IsOK(ecode2)) {
29938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29939 }
29940 arg2 = static_cast< int >(val2);
29941 ecode3 = SWIG_AsVal_int(obj2, &val3);
29942 if (!SWIG_IsOK(ecode3)) {
29943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29944 }
29945 arg3 = static_cast< int >(val3);
29946 ecode4 = SWIG_AsVal_int(obj3, &val4);
29947 if (!SWIG_IsOK(ecode4)) {
29948 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29949 }
29950 arg4 = static_cast< int >(val4);
29951 {
29952 PyThreadState* __tstate = wxPyBeginAllowThreads();
29953 (arg1)->Set(arg2,arg3,arg4);
29954 wxPyEndAllowThreads(__tstate);
29955 if (PyErr_Occurred()) SWIG_fail;
29956 }
29957 resultobj = SWIG_Py_Void();
29958 return resultobj;
29959 fail:
29960 return NULL;
29961 }
29962
29963
29964 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29965 PyObject *resultobj = 0;
29966 wxString *arg1 = 0 ;
29967 wxAcceleratorEntry *result = 0 ;
29968 bool temp1 = false ;
29969 PyObject * obj0 = 0 ;
29970 char * kwnames[] = {
29971 (char *) "str", NULL
29972 };
29973
29974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29975 {
29976 arg1 = wxString_in_helper(obj0);
29977 if (arg1 == NULL) SWIG_fail;
29978 temp1 = true;
29979 }
29980 {
29981 PyThreadState* __tstate = wxPyBeginAllowThreads();
29982 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29983 wxPyEndAllowThreads(__tstate);
29984 if (PyErr_Occurred()) SWIG_fail;
29985 }
29986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29987 {
29988 if (temp1)
29989 delete arg1;
29990 }
29991 return resultobj;
29992 fail:
29993 {
29994 if (temp1)
29995 delete arg1;
29996 }
29997 return NULL;
29998 }
29999
30000
30001 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30002 PyObject *resultobj = 0;
30003 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30004 int result;
30005 void *argp1 = 0 ;
30006 int res1 = 0 ;
30007 PyObject *swig_obj[1] ;
30008
30009 if (!args) SWIG_fail;
30010 swig_obj[0] = args;
30011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30012 if (!SWIG_IsOK(res1)) {
30013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30014 }
30015 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30016 {
30017 PyThreadState* __tstate = wxPyBeginAllowThreads();
30018 result = (int)(arg1)->GetFlags();
30019 wxPyEndAllowThreads(__tstate);
30020 if (PyErr_Occurred()) SWIG_fail;
30021 }
30022 resultobj = SWIG_From_int(static_cast< int >(result));
30023 return resultobj;
30024 fail:
30025 return NULL;
30026 }
30027
30028
30029 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30030 PyObject *resultobj = 0;
30031 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 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_wxAcceleratorEntry, 0 | 0 );
30040 if (!SWIG_IsOK(res1)) {
30041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30042 }
30043 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30044 {
30045 PyThreadState* __tstate = wxPyBeginAllowThreads();
30046 result = (int)(arg1)->GetKeyCode();
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_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30058 PyObject *resultobj = 0;
30059 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30060 int result;
30061 void *argp1 = 0 ;
30062 int res1 = 0 ;
30063 PyObject *swig_obj[1] ;
30064
30065 if (!args) SWIG_fail;
30066 swig_obj[0] = args;
30067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30068 if (!SWIG_IsOK(res1)) {
30069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30070 }
30071 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30072 {
30073 PyThreadState* __tstate = wxPyBeginAllowThreads();
30074 result = (int)(arg1)->GetCommand();
30075 wxPyEndAllowThreads(__tstate);
30076 if (PyErr_Occurred()) SWIG_fail;
30077 }
30078 resultobj = SWIG_From_int(static_cast< int >(result));
30079 return resultobj;
30080 fail:
30081 return NULL;
30082 }
30083
30084
30085 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30086 PyObject *resultobj = 0;
30087 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30088 bool result;
30089 void *argp1 = 0 ;
30090 int res1 = 0 ;
30091 PyObject *swig_obj[1] ;
30092
30093 if (!args) SWIG_fail;
30094 swig_obj[0] = args;
30095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30096 if (!SWIG_IsOK(res1)) {
30097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30098 }
30099 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30100 {
30101 PyThreadState* __tstate = wxPyBeginAllowThreads();
30102 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
30103 wxPyEndAllowThreads(__tstate);
30104 if (PyErr_Occurred()) SWIG_fail;
30105 }
30106 {
30107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30108 }
30109 return resultobj;
30110 fail:
30111 return NULL;
30112 }
30113
30114
30115 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30116 PyObject *resultobj = 0;
30117 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30118 wxString result;
30119 void *argp1 = 0 ;
30120 int res1 = 0 ;
30121 PyObject *swig_obj[1] ;
30122
30123 if (!args) SWIG_fail;
30124 swig_obj[0] = args;
30125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30126 if (!SWIG_IsOK(res1)) {
30127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30128 }
30129 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30130 {
30131 PyThreadState* __tstate = wxPyBeginAllowThreads();
30132 result = ((wxAcceleratorEntry const *)arg1)->ToString();
30133 wxPyEndAllowThreads(__tstate);
30134 if (PyErr_Occurred()) SWIG_fail;
30135 }
30136 {
30137 #if wxUSE_UNICODE
30138 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30139 #else
30140 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30141 #endif
30142 }
30143 return resultobj;
30144 fail:
30145 return NULL;
30146 }
30147
30148
30149 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30150 PyObject *resultobj = 0;
30151 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30152 wxString *arg2 = 0 ;
30153 bool result;
30154 void *argp1 = 0 ;
30155 int res1 = 0 ;
30156 bool temp2 = false ;
30157 PyObject * obj0 = 0 ;
30158 PyObject * obj1 = 0 ;
30159 char * kwnames[] = {
30160 (char *) "self",(char *) "str", NULL
30161 };
30162
30163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
30164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30165 if (!SWIG_IsOK(res1)) {
30166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30167 }
30168 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30169 {
30170 arg2 = wxString_in_helper(obj1);
30171 if (arg2 == NULL) SWIG_fail;
30172 temp2 = true;
30173 }
30174 {
30175 PyThreadState* __tstate = wxPyBeginAllowThreads();
30176 result = (bool)(arg1)->FromString((wxString const &)*arg2);
30177 wxPyEndAllowThreads(__tstate);
30178 if (PyErr_Occurred()) SWIG_fail;
30179 }
30180 {
30181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30182 }
30183 {
30184 if (temp2)
30185 delete arg2;
30186 }
30187 return resultobj;
30188 fail:
30189 {
30190 if (temp2)
30191 delete arg2;
30192 }
30193 return NULL;
30194 }
30195
30196
30197 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30198 PyObject *obj;
30199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30200 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
30201 return SWIG_Py_Void();
30202 }
30203
30204 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30205 return SWIG_Python_InitShadowInstance(args);
30206 }
30207
30208 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30209 PyObject *resultobj = 0;
30210 int arg1 ;
30211 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
30212 wxAcceleratorTable *result = 0 ;
30213 PyObject * obj0 = 0 ;
30214 char * kwnames[] = {
30215 (char *) "n", NULL
30216 };
30217
30218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
30219 {
30220 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
30221 if (arg2) arg1 = PyList_Size(obj0);
30222 else arg1 = 0;
30223 }
30224 {
30225 PyThreadState* __tstate = wxPyBeginAllowThreads();
30226 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
30227 wxPyEndAllowThreads(__tstate);
30228 if (PyErr_Occurred()) SWIG_fail;
30229 }
30230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
30231 return resultobj;
30232 fail:
30233 return NULL;
30234 }
30235
30236
30237 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30238 PyObject *resultobj = 0;
30239 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30240 void *argp1 = 0 ;
30241 int res1 = 0 ;
30242 PyObject *swig_obj[1] ;
30243
30244 if (!args) SWIG_fail;
30245 swig_obj[0] = args;
30246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
30247 if (!SWIG_IsOK(res1)) {
30248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
30249 }
30250 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30251 {
30252 PyThreadState* __tstate = wxPyBeginAllowThreads();
30253 delete arg1;
30254
30255 wxPyEndAllowThreads(__tstate);
30256 if (PyErr_Occurred()) SWIG_fail;
30257 }
30258 resultobj = SWIG_Py_Void();
30259 return resultobj;
30260 fail:
30261 return NULL;
30262 }
30263
30264
30265 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30266 PyObject *resultobj = 0;
30267 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30268 bool result;
30269 void *argp1 = 0 ;
30270 int res1 = 0 ;
30271 PyObject *swig_obj[1] ;
30272
30273 if (!args) SWIG_fail;
30274 swig_obj[0] = args;
30275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
30276 if (!SWIG_IsOK(res1)) {
30277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
30278 }
30279 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30280 {
30281 PyThreadState* __tstate = wxPyBeginAllowThreads();
30282 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
30283 wxPyEndAllowThreads(__tstate);
30284 if (PyErr_Occurred()) SWIG_fail;
30285 }
30286 {
30287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30288 }
30289 return resultobj;
30290 fail:
30291 return NULL;
30292 }
30293
30294
30295 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30296 PyObject *obj;
30297 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30298 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
30299 return SWIG_Py_Void();
30300 }
30301
30302 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30303 return SWIG_Python_InitShadowInstance(args);
30304 }
30305
30306 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
30307 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
30308 return 1;
30309 }
30310
30311
30312 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
30313 PyObject *pyobj = 0;
30314
30315 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
30316 return pyobj;
30317 }
30318
30319
30320 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30321 PyObject *resultobj = 0;
30322 wxString *arg1 = 0 ;
30323 wxAcceleratorEntry *result = 0 ;
30324 bool temp1 = false ;
30325 PyObject * obj0 = 0 ;
30326 char * kwnames[] = {
30327 (char *) "label", NULL
30328 };
30329
30330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
30331 {
30332 arg1 = wxString_in_helper(obj0);
30333 if (arg1 == NULL) SWIG_fail;
30334 temp1 = true;
30335 }
30336 {
30337 PyThreadState* __tstate = wxPyBeginAllowThreads();
30338 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
30339 wxPyEndAllowThreads(__tstate);
30340 if (PyErr_Occurred()) SWIG_fail;
30341 }
30342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30343 {
30344 if (temp1)
30345 delete arg1;
30346 }
30347 return resultobj;
30348 fail:
30349 {
30350 if (temp1)
30351 delete arg1;
30352 }
30353 return NULL;
30354 }
30355
30356
30357 SWIGINTERN int PanelNameStr_set(PyObject *) {
30358 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
30359 return 1;
30360 }
30361
30362
30363 SWIGINTERN PyObject *PanelNameStr_get(void) {
30364 PyObject *pyobj = 0;
30365
30366 {
30367 #if wxUSE_UNICODE
30368 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30369 #else
30370 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30371 #endif
30372 }
30373 return pyobj;
30374 }
30375
30376
30377 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30378 PyObject *resultobj = 0;
30379 wxVisualAttributes *result = 0 ;
30380
30381 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
30382 {
30383 PyThreadState* __tstate = wxPyBeginAllowThreads();
30384 result = (wxVisualAttributes *)new_wxVisualAttributes();
30385 wxPyEndAllowThreads(__tstate);
30386 if (PyErr_Occurred()) SWIG_fail;
30387 }
30388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
30389 return resultobj;
30390 fail:
30391 return NULL;
30392 }
30393
30394
30395 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30396 PyObject *resultobj = 0;
30397 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30398 void *argp1 = 0 ;
30399 int res1 = 0 ;
30400 PyObject *swig_obj[1] ;
30401
30402 if (!args) SWIG_fail;
30403 swig_obj[0] = args;
30404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
30405 if (!SWIG_IsOK(res1)) {
30406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30407 }
30408 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30409 {
30410 PyThreadState* __tstate = wxPyBeginAllowThreads();
30411 delete_wxVisualAttributes(arg1);
30412
30413 wxPyEndAllowThreads(__tstate);
30414 if (PyErr_Occurred()) SWIG_fail;
30415 }
30416 resultobj = SWIG_Py_Void();
30417 return resultobj;
30418 fail:
30419 return NULL;
30420 }
30421
30422
30423 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30424 PyObject *resultobj = 0;
30425 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30426 wxFont *arg2 = (wxFont *) 0 ;
30427 void *argp1 = 0 ;
30428 int res1 = 0 ;
30429 void *argp2 = 0 ;
30430 int res2 = 0 ;
30431 PyObject *swig_obj[2] ;
30432
30433 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
30434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30435 if (!SWIG_IsOK(res1)) {
30436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30437 }
30438 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30439 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
30440 if (!SWIG_IsOK(res2)) {
30441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
30442 }
30443 arg2 = reinterpret_cast< wxFont * >(argp2);
30444 if (arg1) (arg1)->font = *arg2;
30445
30446 resultobj = SWIG_Py_Void();
30447 return resultobj;
30448 fail:
30449 return NULL;
30450 }
30451
30452
30453 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30454 PyObject *resultobj = 0;
30455 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30456 wxFont *result = 0 ;
30457 void *argp1 = 0 ;
30458 int res1 = 0 ;
30459 PyObject *swig_obj[1] ;
30460
30461 if (!args) SWIG_fail;
30462 swig_obj[0] = args;
30463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30464 if (!SWIG_IsOK(res1)) {
30465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30466 }
30467 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30468 result = (wxFont *)& ((arg1)->font);
30469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
30470 return resultobj;
30471 fail:
30472 return NULL;
30473 }
30474
30475
30476 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30477 PyObject *resultobj = 0;
30478 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30479 wxColour *arg2 = (wxColour *) 0 ;
30480 void *argp1 = 0 ;
30481 int res1 = 0 ;
30482 void *argp2 = 0 ;
30483 int res2 = 0 ;
30484 PyObject *swig_obj[2] ;
30485
30486 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
30487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30488 if (!SWIG_IsOK(res1)) {
30489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30490 }
30491 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30492 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30493 if (!SWIG_IsOK(res2)) {
30494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30495 }
30496 arg2 = reinterpret_cast< wxColour * >(argp2);
30497 if (arg1) (arg1)->colFg = *arg2;
30498
30499 resultobj = SWIG_Py_Void();
30500 return resultobj;
30501 fail:
30502 return NULL;
30503 }
30504
30505
30506 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30507 PyObject *resultobj = 0;
30508 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30509 wxColour *result = 0 ;
30510 void *argp1 = 0 ;
30511 int res1 = 0 ;
30512 PyObject *swig_obj[1] ;
30513
30514 if (!args) SWIG_fail;
30515 swig_obj[0] = args;
30516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30517 if (!SWIG_IsOK(res1)) {
30518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30519 }
30520 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30521 result = (wxColour *)& ((arg1)->colFg);
30522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30523 return resultobj;
30524 fail:
30525 return NULL;
30526 }
30527
30528
30529 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30530 PyObject *resultobj = 0;
30531 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30532 wxColour *arg2 = (wxColour *) 0 ;
30533 void *argp1 = 0 ;
30534 int res1 = 0 ;
30535 void *argp2 = 0 ;
30536 int res2 = 0 ;
30537 PyObject *swig_obj[2] ;
30538
30539 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
30540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30541 if (!SWIG_IsOK(res1)) {
30542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30543 }
30544 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30545 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30546 if (!SWIG_IsOK(res2)) {
30547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30548 }
30549 arg2 = reinterpret_cast< wxColour * >(argp2);
30550 if (arg1) (arg1)->colBg = *arg2;
30551
30552 resultobj = SWIG_Py_Void();
30553 return resultobj;
30554 fail:
30555 return NULL;
30556 }
30557
30558
30559 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30560 PyObject *resultobj = 0;
30561 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30562 wxColour *result = 0 ;
30563 void *argp1 = 0 ;
30564 int res1 = 0 ;
30565 PyObject *swig_obj[1] ;
30566
30567 if (!args) SWIG_fail;
30568 swig_obj[0] = args;
30569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30570 if (!SWIG_IsOK(res1)) {
30571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30572 }
30573 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30574 result = (wxColour *)& ((arg1)->colBg);
30575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30576 return resultobj;
30577 fail:
30578 return NULL;
30579 }
30580
30581
30582 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30583 PyObject *obj;
30584 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30585 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30586 return SWIG_Py_Void();
30587 }
30588
30589 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30590 return SWIG_Python_InitShadowInstance(args);
30591 }
30592
30593 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30594 PyObject *resultobj = 0;
30595 wxWindow *arg1 = (wxWindow *) 0 ;
30596 int arg2 = (int) (int)-1 ;
30597 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30598 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30599 wxSize const &arg4_defvalue = wxDefaultSize ;
30600 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30601 long arg5 = (long) 0 ;
30602 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30603 wxString *arg6 = (wxString *) &arg6_defvalue ;
30604 wxWindow *result = 0 ;
30605 void *argp1 = 0 ;
30606 int res1 = 0 ;
30607 int val2 ;
30608 int ecode2 = 0 ;
30609 wxPoint temp3 ;
30610 wxSize temp4 ;
30611 long val5 ;
30612 int ecode5 = 0 ;
30613 bool temp6 = false ;
30614 PyObject * obj0 = 0 ;
30615 PyObject * obj1 = 0 ;
30616 PyObject * obj2 = 0 ;
30617 PyObject * obj3 = 0 ;
30618 PyObject * obj4 = 0 ;
30619 PyObject * obj5 = 0 ;
30620 char * kwnames[] = {
30621 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30622 };
30623
30624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30626 if (!SWIG_IsOK(res1)) {
30627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30628 }
30629 arg1 = reinterpret_cast< wxWindow * >(argp1);
30630 if (obj1) {
30631 ecode2 = SWIG_AsVal_int(obj1, &val2);
30632 if (!SWIG_IsOK(ecode2)) {
30633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30634 }
30635 arg2 = static_cast< int >(val2);
30636 }
30637 if (obj2) {
30638 {
30639 arg3 = &temp3;
30640 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30641 }
30642 }
30643 if (obj3) {
30644 {
30645 arg4 = &temp4;
30646 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30647 }
30648 }
30649 if (obj4) {
30650 ecode5 = SWIG_AsVal_long(obj4, &val5);
30651 if (!SWIG_IsOK(ecode5)) {
30652 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30653 }
30654 arg5 = static_cast< long >(val5);
30655 }
30656 if (obj5) {
30657 {
30658 arg6 = wxString_in_helper(obj5);
30659 if (arg6 == NULL) SWIG_fail;
30660 temp6 = true;
30661 }
30662 }
30663 {
30664 if (!wxPyCheckForApp()) SWIG_fail;
30665 PyThreadState* __tstate = wxPyBeginAllowThreads();
30666 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30667 wxPyEndAllowThreads(__tstate);
30668 if (PyErr_Occurred()) SWIG_fail;
30669 }
30670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30671 {
30672 if (temp6)
30673 delete arg6;
30674 }
30675 return resultobj;
30676 fail:
30677 {
30678 if (temp6)
30679 delete arg6;
30680 }
30681 return NULL;
30682 }
30683
30684
30685 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30686 PyObject *resultobj = 0;
30687 wxWindow *result = 0 ;
30688
30689 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30690 {
30691 if (!wxPyCheckForApp()) SWIG_fail;
30692 PyThreadState* __tstate = wxPyBeginAllowThreads();
30693 result = (wxWindow *)new wxWindow();
30694 wxPyEndAllowThreads(__tstate);
30695 if (PyErr_Occurred()) SWIG_fail;
30696 }
30697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30698 return resultobj;
30699 fail:
30700 return NULL;
30701 }
30702
30703
30704 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30705 PyObject *resultobj = 0;
30706 wxWindow *arg1 = (wxWindow *) 0 ;
30707 wxWindow *arg2 = (wxWindow *) 0 ;
30708 int arg3 = (int) (int)-1 ;
30709 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30710 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30711 wxSize const &arg5_defvalue = wxDefaultSize ;
30712 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30713 long arg6 = (long) 0 ;
30714 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30715 wxString *arg7 = (wxString *) &arg7_defvalue ;
30716 bool result;
30717 void *argp1 = 0 ;
30718 int res1 = 0 ;
30719 void *argp2 = 0 ;
30720 int res2 = 0 ;
30721 int val3 ;
30722 int ecode3 = 0 ;
30723 wxPoint temp4 ;
30724 wxSize temp5 ;
30725 long val6 ;
30726 int ecode6 = 0 ;
30727 bool temp7 = false ;
30728 PyObject * obj0 = 0 ;
30729 PyObject * obj1 = 0 ;
30730 PyObject * obj2 = 0 ;
30731 PyObject * obj3 = 0 ;
30732 PyObject * obj4 = 0 ;
30733 PyObject * obj5 = 0 ;
30734 PyObject * obj6 = 0 ;
30735 char * kwnames[] = {
30736 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30737 };
30738
30739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30741 if (!SWIG_IsOK(res1)) {
30742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30743 }
30744 arg1 = reinterpret_cast< wxWindow * >(argp1);
30745 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30746 if (!SWIG_IsOK(res2)) {
30747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30748 }
30749 arg2 = reinterpret_cast< wxWindow * >(argp2);
30750 if (obj2) {
30751 ecode3 = SWIG_AsVal_int(obj2, &val3);
30752 if (!SWIG_IsOK(ecode3)) {
30753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30754 }
30755 arg3 = static_cast< int >(val3);
30756 }
30757 if (obj3) {
30758 {
30759 arg4 = &temp4;
30760 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30761 }
30762 }
30763 if (obj4) {
30764 {
30765 arg5 = &temp5;
30766 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30767 }
30768 }
30769 if (obj5) {
30770 ecode6 = SWIG_AsVal_long(obj5, &val6);
30771 if (!SWIG_IsOK(ecode6)) {
30772 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30773 }
30774 arg6 = static_cast< long >(val6);
30775 }
30776 if (obj6) {
30777 {
30778 arg7 = wxString_in_helper(obj6);
30779 if (arg7 == NULL) SWIG_fail;
30780 temp7 = true;
30781 }
30782 }
30783 {
30784 PyThreadState* __tstate = wxPyBeginAllowThreads();
30785 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30786 wxPyEndAllowThreads(__tstate);
30787 if (PyErr_Occurred()) SWIG_fail;
30788 }
30789 {
30790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30791 }
30792 {
30793 if (temp7)
30794 delete arg7;
30795 }
30796 return resultobj;
30797 fail:
30798 {
30799 if (temp7)
30800 delete arg7;
30801 }
30802 return NULL;
30803 }
30804
30805
30806 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30807 PyObject *resultobj = 0;
30808 wxWindow *arg1 = (wxWindow *) 0 ;
30809 bool arg2 = (bool) false ;
30810 bool result;
30811 void *argp1 = 0 ;
30812 int res1 = 0 ;
30813 bool val2 ;
30814 int ecode2 = 0 ;
30815 PyObject * obj0 = 0 ;
30816 PyObject * obj1 = 0 ;
30817 char * kwnames[] = {
30818 (char *) "self",(char *) "force", NULL
30819 };
30820
30821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30823 if (!SWIG_IsOK(res1)) {
30824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30825 }
30826 arg1 = reinterpret_cast< wxWindow * >(argp1);
30827 if (obj1) {
30828 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30829 if (!SWIG_IsOK(ecode2)) {
30830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30831 }
30832 arg2 = static_cast< bool >(val2);
30833 }
30834 {
30835 PyThreadState* __tstate = wxPyBeginAllowThreads();
30836 result = (bool)(arg1)->Close(arg2);
30837 wxPyEndAllowThreads(__tstate);
30838 if (PyErr_Occurred()) SWIG_fail;
30839 }
30840 {
30841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30842 }
30843 return resultobj;
30844 fail:
30845 return NULL;
30846 }
30847
30848
30849 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30850 PyObject *resultobj = 0;
30851 wxWindow *arg1 = (wxWindow *) 0 ;
30852 bool result;
30853 void *argp1 = 0 ;
30854 int res1 = 0 ;
30855 PyObject *swig_obj[1] ;
30856
30857 if (!args) SWIG_fail;
30858 swig_obj[0] = args;
30859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30860 if (!SWIG_IsOK(res1)) {
30861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30862 }
30863 arg1 = reinterpret_cast< wxWindow * >(argp1);
30864 {
30865 PyThreadState* __tstate = wxPyBeginAllowThreads();
30866 result = (bool)(arg1)->Destroy();
30867 wxPyEndAllowThreads(__tstate);
30868 if (PyErr_Occurred()) SWIG_fail;
30869 }
30870 {
30871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30872 }
30873 return resultobj;
30874 fail:
30875 return NULL;
30876 }
30877
30878
30879 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30880 PyObject *resultobj = 0;
30881 wxWindow *arg1 = (wxWindow *) 0 ;
30882 bool result;
30883 void *argp1 = 0 ;
30884 int res1 = 0 ;
30885 PyObject *swig_obj[1] ;
30886
30887 if (!args) SWIG_fail;
30888 swig_obj[0] = args;
30889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30890 if (!SWIG_IsOK(res1)) {
30891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30892 }
30893 arg1 = reinterpret_cast< wxWindow * >(argp1);
30894 {
30895 PyThreadState* __tstate = wxPyBeginAllowThreads();
30896 result = (bool)(arg1)->DestroyChildren();
30897 wxPyEndAllowThreads(__tstate);
30898 if (PyErr_Occurred()) SWIG_fail;
30899 }
30900 {
30901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30902 }
30903 return resultobj;
30904 fail:
30905 return NULL;
30906 }
30907
30908
30909 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30910 PyObject *resultobj = 0;
30911 wxWindow *arg1 = (wxWindow *) 0 ;
30912 bool result;
30913 void *argp1 = 0 ;
30914 int res1 = 0 ;
30915 PyObject *swig_obj[1] ;
30916
30917 if (!args) SWIG_fail;
30918 swig_obj[0] = args;
30919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30920 if (!SWIG_IsOK(res1)) {
30921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30922 }
30923 arg1 = reinterpret_cast< wxWindow * >(argp1);
30924 {
30925 PyThreadState* __tstate = wxPyBeginAllowThreads();
30926 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30927 wxPyEndAllowThreads(__tstate);
30928 if (PyErr_Occurred()) SWIG_fail;
30929 }
30930 {
30931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30932 }
30933 return resultobj;
30934 fail:
30935 return NULL;
30936 }
30937
30938
30939 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30940 PyObject *resultobj = 0;
30941 wxWindow *arg1 = (wxWindow *) 0 ;
30942 wxString *arg2 = 0 ;
30943 void *argp1 = 0 ;
30944 int res1 = 0 ;
30945 bool temp2 = false ;
30946 PyObject * obj0 = 0 ;
30947 PyObject * obj1 = 0 ;
30948 char * kwnames[] = {
30949 (char *) "self",(char *) "label", NULL
30950 };
30951
30952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30954 if (!SWIG_IsOK(res1)) {
30955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30956 }
30957 arg1 = reinterpret_cast< wxWindow * >(argp1);
30958 {
30959 arg2 = wxString_in_helper(obj1);
30960 if (arg2 == NULL) SWIG_fail;
30961 temp2 = true;
30962 }
30963 {
30964 PyThreadState* __tstate = wxPyBeginAllowThreads();
30965 (arg1)->SetLabel((wxString const &)*arg2);
30966 wxPyEndAllowThreads(__tstate);
30967 if (PyErr_Occurred()) SWIG_fail;
30968 }
30969 resultobj = SWIG_Py_Void();
30970 {
30971 if (temp2)
30972 delete arg2;
30973 }
30974 return resultobj;
30975 fail:
30976 {
30977 if (temp2)
30978 delete arg2;
30979 }
30980 return NULL;
30981 }
30982
30983
30984 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30985 PyObject *resultobj = 0;
30986 wxWindow *arg1 = (wxWindow *) 0 ;
30987 wxString result;
30988 void *argp1 = 0 ;
30989 int res1 = 0 ;
30990 PyObject *swig_obj[1] ;
30991
30992 if (!args) SWIG_fail;
30993 swig_obj[0] = args;
30994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30995 if (!SWIG_IsOK(res1)) {
30996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30997 }
30998 arg1 = reinterpret_cast< wxWindow * >(argp1);
30999 {
31000 PyThreadState* __tstate = wxPyBeginAllowThreads();
31001 result = ((wxWindow const *)arg1)->GetLabel();
31002 wxPyEndAllowThreads(__tstate);
31003 if (PyErr_Occurred()) SWIG_fail;
31004 }
31005 {
31006 #if wxUSE_UNICODE
31007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31008 #else
31009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31010 #endif
31011 }
31012 return resultobj;
31013 fail:
31014 return NULL;
31015 }
31016
31017
31018 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31019 PyObject *resultobj = 0;
31020 wxWindow *arg1 = (wxWindow *) 0 ;
31021 wxString *arg2 = 0 ;
31022 void *argp1 = 0 ;
31023 int res1 = 0 ;
31024 bool temp2 = false ;
31025 PyObject * obj0 = 0 ;
31026 PyObject * obj1 = 0 ;
31027 char * kwnames[] = {
31028 (char *) "self",(char *) "name", NULL
31029 };
31030
31031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
31032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31033 if (!SWIG_IsOK(res1)) {
31034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
31035 }
31036 arg1 = reinterpret_cast< wxWindow * >(argp1);
31037 {
31038 arg2 = wxString_in_helper(obj1);
31039 if (arg2 == NULL) SWIG_fail;
31040 temp2 = true;
31041 }
31042 {
31043 PyThreadState* __tstate = wxPyBeginAllowThreads();
31044 (arg1)->SetName((wxString const &)*arg2);
31045 wxPyEndAllowThreads(__tstate);
31046 if (PyErr_Occurred()) SWIG_fail;
31047 }
31048 resultobj = SWIG_Py_Void();
31049 {
31050 if (temp2)
31051 delete arg2;
31052 }
31053 return resultobj;
31054 fail:
31055 {
31056 if (temp2)
31057 delete arg2;
31058 }
31059 return NULL;
31060 }
31061
31062
31063 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31064 PyObject *resultobj = 0;
31065 wxWindow *arg1 = (wxWindow *) 0 ;
31066 wxString result;
31067 void *argp1 = 0 ;
31068 int res1 = 0 ;
31069 PyObject *swig_obj[1] ;
31070
31071 if (!args) SWIG_fail;
31072 swig_obj[0] = args;
31073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31074 if (!SWIG_IsOK(res1)) {
31075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
31076 }
31077 arg1 = reinterpret_cast< wxWindow * >(argp1);
31078 {
31079 PyThreadState* __tstate = wxPyBeginAllowThreads();
31080 result = ((wxWindow const *)arg1)->GetName();
31081 wxPyEndAllowThreads(__tstate);
31082 if (PyErr_Occurred()) SWIG_fail;
31083 }
31084 {
31085 #if wxUSE_UNICODE
31086 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31087 #else
31088 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31089 #endif
31090 }
31091 return resultobj;
31092 fail:
31093 return NULL;
31094 }
31095
31096
31097 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31098 PyObject *resultobj = 0;
31099 wxWindow *arg1 = (wxWindow *) 0 ;
31100 wxWindowVariant arg2 ;
31101 void *argp1 = 0 ;
31102 int res1 = 0 ;
31103 int val2 ;
31104 int ecode2 = 0 ;
31105 PyObject * obj0 = 0 ;
31106 PyObject * obj1 = 0 ;
31107 char * kwnames[] = {
31108 (char *) "self",(char *) "variant", NULL
31109 };
31110
31111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
31112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31113 if (!SWIG_IsOK(res1)) {
31114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
31115 }
31116 arg1 = reinterpret_cast< wxWindow * >(argp1);
31117 ecode2 = SWIG_AsVal_int(obj1, &val2);
31118 if (!SWIG_IsOK(ecode2)) {
31119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
31120 }
31121 arg2 = static_cast< wxWindowVariant >(val2);
31122 {
31123 PyThreadState* __tstate = wxPyBeginAllowThreads();
31124 (arg1)->SetWindowVariant(arg2);
31125 wxPyEndAllowThreads(__tstate);
31126 if (PyErr_Occurred()) SWIG_fail;
31127 }
31128 resultobj = SWIG_Py_Void();
31129 return resultobj;
31130 fail:
31131 return NULL;
31132 }
31133
31134
31135 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31136 PyObject *resultobj = 0;
31137 wxWindow *arg1 = (wxWindow *) 0 ;
31138 wxWindowVariant result;
31139 void *argp1 = 0 ;
31140 int res1 = 0 ;
31141 PyObject *swig_obj[1] ;
31142
31143 if (!args) SWIG_fail;
31144 swig_obj[0] = args;
31145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31146 if (!SWIG_IsOK(res1)) {
31147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
31148 }
31149 arg1 = reinterpret_cast< wxWindow * >(argp1);
31150 {
31151 PyThreadState* __tstate = wxPyBeginAllowThreads();
31152 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
31153 wxPyEndAllowThreads(__tstate);
31154 if (PyErr_Occurred()) SWIG_fail;
31155 }
31156 resultobj = SWIG_From_int(static_cast< int >(result));
31157 return resultobj;
31158 fail:
31159 return NULL;
31160 }
31161
31162
31163 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31164 PyObject *resultobj = 0;
31165 wxWindow *arg1 = (wxWindow *) 0 ;
31166 int arg2 ;
31167 void *argp1 = 0 ;
31168 int res1 = 0 ;
31169 int val2 ;
31170 int ecode2 = 0 ;
31171 PyObject * obj0 = 0 ;
31172 PyObject * obj1 = 0 ;
31173 char * kwnames[] = {
31174 (char *) "self",(char *) "winid", NULL
31175 };
31176
31177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31179 if (!SWIG_IsOK(res1)) {
31180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
31181 }
31182 arg1 = reinterpret_cast< wxWindow * >(argp1);
31183 ecode2 = SWIG_AsVal_int(obj1, &val2);
31184 if (!SWIG_IsOK(ecode2)) {
31185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
31186 }
31187 arg2 = static_cast< int >(val2);
31188 {
31189 PyThreadState* __tstate = wxPyBeginAllowThreads();
31190 (arg1)->SetId(arg2);
31191 wxPyEndAllowThreads(__tstate);
31192 if (PyErr_Occurred()) SWIG_fail;
31193 }
31194 resultobj = SWIG_Py_Void();
31195 return resultobj;
31196 fail:
31197 return NULL;
31198 }
31199
31200
31201 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31202 PyObject *resultobj = 0;
31203 wxWindow *arg1 = (wxWindow *) 0 ;
31204 int result;
31205 void *argp1 = 0 ;
31206 int res1 = 0 ;
31207 PyObject *swig_obj[1] ;
31208
31209 if (!args) SWIG_fail;
31210 swig_obj[0] = args;
31211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31212 if (!SWIG_IsOK(res1)) {
31213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
31214 }
31215 arg1 = reinterpret_cast< wxWindow * >(argp1);
31216 {
31217 PyThreadState* __tstate = wxPyBeginAllowThreads();
31218 result = (int)((wxWindow const *)arg1)->GetId();
31219 wxPyEndAllowThreads(__tstate);
31220 if (PyErr_Occurred()) SWIG_fail;
31221 }
31222 resultobj = SWIG_From_int(static_cast< int >(result));
31223 return resultobj;
31224 fail:
31225 return NULL;
31226 }
31227
31228
31229 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31230 PyObject *resultobj = 0;
31231 int result;
31232
31233 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
31234 {
31235 PyThreadState* __tstate = wxPyBeginAllowThreads();
31236 result = (int)wxWindow::NewControlId();
31237 wxPyEndAllowThreads(__tstate);
31238 if (PyErr_Occurred()) SWIG_fail;
31239 }
31240 resultobj = SWIG_From_int(static_cast< int >(result));
31241 return resultobj;
31242 fail:
31243 return NULL;
31244 }
31245
31246
31247 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31248 PyObject *resultobj = 0;
31249 int arg1 ;
31250 int result;
31251 int val1 ;
31252 int ecode1 = 0 ;
31253 PyObject * obj0 = 0 ;
31254 char * kwnames[] = {
31255 (char *) "winid", NULL
31256 };
31257
31258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
31259 ecode1 = SWIG_AsVal_int(obj0, &val1);
31260 if (!SWIG_IsOK(ecode1)) {
31261 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
31262 }
31263 arg1 = static_cast< int >(val1);
31264 {
31265 PyThreadState* __tstate = wxPyBeginAllowThreads();
31266 result = (int)wxWindow::NextControlId(arg1);
31267 wxPyEndAllowThreads(__tstate);
31268 if (PyErr_Occurred()) SWIG_fail;
31269 }
31270 resultobj = SWIG_From_int(static_cast< int >(result));
31271 return resultobj;
31272 fail:
31273 return NULL;
31274 }
31275
31276
31277 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31278 PyObject *resultobj = 0;
31279 int arg1 ;
31280 int result;
31281 int val1 ;
31282 int ecode1 = 0 ;
31283 PyObject * obj0 = 0 ;
31284 char * kwnames[] = {
31285 (char *) "winid", NULL
31286 };
31287
31288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
31289 ecode1 = SWIG_AsVal_int(obj0, &val1);
31290 if (!SWIG_IsOK(ecode1)) {
31291 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
31292 }
31293 arg1 = static_cast< int >(val1);
31294 {
31295 PyThreadState* __tstate = wxPyBeginAllowThreads();
31296 result = (int)wxWindow::PrevControlId(arg1);
31297 wxPyEndAllowThreads(__tstate);
31298 if (PyErr_Occurred()) SWIG_fail;
31299 }
31300 resultobj = SWIG_From_int(static_cast< int >(result));
31301 return resultobj;
31302 fail:
31303 return NULL;
31304 }
31305
31306
31307 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31308 PyObject *resultobj = 0;
31309 wxWindow *arg1 = (wxWindow *) 0 ;
31310 wxLayoutDirection result;
31311 void *argp1 = 0 ;
31312 int res1 = 0 ;
31313 PyObject *swig_obj[1] ;
31314
31315 if (!args) SWIG_fail;
31316 swig_obj[0] = args;
31317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31318 if (!SWIG_IsOK(res1)) {
31319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31320 }
31321 arg1 = reinterpret_cast< wxWindow * >(argp1);
31322 {
31323 PyThreadState* __tstate = wxPyBeginAllowThreads();
31324 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
31325 wxPyEndAllowThreads(__tstate);
31326 if (PyErr_Occurred()) SWIG_fail;
31327 }
31328 resultobj = SWIG_From_int(static_cast< int >(result));
31329 return resultobj;
31330 fail:
31331 return NULL;
31332 }
31333
31334
31335 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31336 PyObject *resultobj = 0;
31337 wxWindow *arg1 = (wxWindow *) 0 ;
31338 wxLayoutDirection arg2 ;
31339 void *argp1 = 0 ;
31340 int res1 = 0 ;
31341 int val2 ;
31342 int ecode2 = 0 ;
31343 PyObject * obj0 = 0 ;
31344 PyObject * obj1 = 0 ;
31345 char * kwnames[] = {
31346 (char *) "self",(char *) "dir", NULL
31347 };
31348
31349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
31350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31351 if (!SWIG_IsOK(res1)) {
31352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
31353 }
31354 arg1 = reinterpret_cast< wxWindow * >(argp1);
31355 ecode2 = SWIG_AsVal_int(obj1, &val2);
31356 if (!SWIG_IsOK(ecode2)) {
31357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
31358 }
31359 arg2 = static_cast< wxLayoutDirection >(val2);
31360 {
31361 PyThreadState* __tstate = wxPyBeginAllowThreads();
31362 (arg1)->SetLayoutDirection(arg2);
31363 wxPyEndAllowThreads(__tstate);
31364 if (PyErr_Occurred()) SWIG_fail;
31365 }
31366 resultobj = SWIG_Py_Void();
31367 return resultobj;
31368 fail:
31369 return NULL;
31370 }
31371
31372
31373 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31374 PyObject *resultobj = 0;
31375 wxWindow *arg1 = (wxWindow *) 0 ;
31376 int arg2 ;
31377 int arg3 ;
31378 int arg4 ;
31379 int result;
31380 void *argp1 = 0 ;
31381 int res1 = 0 ;
31382 int val2 ;
31383 int ecode2 = 0 ;
31384 int val3 ;
31385 int ecode3 = 0 ;
31386 int val4 ;
31387 int ecode4 = 0 ;
31388 PyObject * obj0 = 0 ;
31389 PyObject * obj1 = 0 ;
31390 PyObject * obj2 = 0 ;
31391 PyObject * obj3 = 0 ;
31392 char * kwnames[] = {
31393 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
31394 };
31395
31396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31398 if (!SWIG_IsOK(res1)) {
31399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31400 }
31401 arg1 = reinterpret_cast< wxWindow * >(argp1);
31402 ecode2 = SWIG_AsVal_int(obj1, &val2);
31403 if (!SWIG_IsOK(ecode2)) {
31404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
31405 }
31406 arg2 = static_cast< int >(val2);
31407 ecode3 = SWIG_AsVal_int(obj2, &val3);
31408 if (!SWIG_IsOK(ecode3)) {
31409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
31410 }
31411 arg3 = static_cast< int >(val3);
31412 ecode4 = SWIG_AsVal_int(obj3, &val4);
31413 if (!SWIG_IsOK(ecode4)) {
31414 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
31415 }
31416 arg4 = static_cast< int >(val4);
31417 {
31418 PyThreadState* __tstate = wxPyBeginAllowThreads();
31419 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
31420 wxPyEndAllowThreads(__tstate);
31421 if (PyErr_Occurred()) SWIG_fail;
31422 }
31423 resultobj = SWIG_From_int(static_cast< int >(result));
31424 return resultobj;
31425 fail:
31426 return NULL;
31427 }
31428
31429
31430 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31431 PyObject *resultobj = 0;
31432 wxWindow *arg1 = (wxWindow *) 0 ;
31433 wxSize *arg2 = 0 ;
31434 void *argp1 = 0 ;
31435 int res1 = 0 ;
31436 wxSize temp2 ;
31437 PyObject * obj0 = 0 ;
31438 PyObject * obj1 = 0 ;
31439 char * kwnames[] = {
31440 (char *) "self",(char *) "size", NULL
31441 };
31442
31443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
31444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31445 if (!SWIG_IsOK(res1)) {
31446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31447 }
31448 arg1 = reinterpret_cast< wxWindow * >(argp1);
31449 {
31450 arg2 = &temp2;
31451 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31452 }
31453 {
31454 PyThreadState* __tstate = wxPyBeginAllowThreads();
31455 (arg1)->SetSize((wxSize const &)*arg2);
31456 wxPyEndAllowThreads(__tstate);
31457 if (PyErr_Occurred()) SWIG_fail;
31458 }
31459 resultobj = SWIG_Py_Void();
31460 return resultobj;
31461 fail:
31462 return NULL;
31463 }
31464
31465
31466 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31467 PyObject *resultobj = 0;
31468 wxWindow *arg1 = (wxWindow *) 0 ;
31469 int arg2 ;
31470 int arg3 ;
31471 int arg4 ;
31472 int arg5 ;
31473 int arg6 = (int) wxSIZE_AUTO ;
31474 void *argp1 = 0 ;
31475 int res1 = 0 ;
31476 int val2 ;
31477 int ecode2 = 0 ;
31478 int val3 ;
31479 int ecode3 = 0 ;
31480 int val4 ;
31481 int ecode4 = 0 ;
31482 int val5 ;
31483 int ecode5 = 0 ;
31484 int val6 ;
31485 int ecode6 = 0 ;
31486 PyObject * obj0 = 0 ;
31487 PyObject * obj1 = 0 ;
31488 PyObject * obj2 = 0 ;
31489 PyObject * obj3 = 0 ;
31490 PyObject * obj4 = 0 ;
31491 PyObject * obj5 = 0 ;
31492 char * kwnames[] = {
31493 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
31494 };
31495
31496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31498 if (!SWIG_IsOK(res1)) {
31499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
31500 }
31501 arg1 = reinterpret_cast< wxWindow * >(argp1);
31502 ecode2 = SWIG_AsVal_int(obj1, &val2);
31503 if (!SWIG_IsOK(ecode2)) {
31504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
31505 }
31506 arg2 = static_cast< int >(val2);
31507 ecode3 = SWIG_AsVal_int(obj2, &val3);
31508 if (!SWIG_IsOK(ecode3)) {
31509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
31510 }
31511 arg3 = static_cast< int >(val3);
31512 ecode4 = SWIG_AsVal_int(obj3, &val4);
31513 if (!SWIG_IsOK(ecode4)) {
31514 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
31515 }
31516 arg4 = static_cast< int >(val4);
31517 ecode5 = SWIG_AsVal_int(obj4, &val5);
31518 if (!SWIG_IsOK(ecode5)) {
31519 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
31520 }
31521 arg5 = static_cast< int >(val5);
31522 if (obj5) {
31523 ecode6 = SWIG_AsVal_int(obj5, &val6);
31524 if (!SWIG_IsOK(ecode6)) {
31525 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
31526 }
31527 arg6 = static_cast< int >(val6);
31528 }
31529 {
31530 PyThreadState* __tstate = wxPyBeginAllowThreads();
31531 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
31532 wxPyEndAllowThreads(__tstate);
31533 if (PyErr_Occurred()) SWIG_fail;
31534 }
31535 resultobj = SWIG_Py_Void();
31536 return resultobj;
31537 fail:
31538 return NULL;
31539 }
31540
31541
31542 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31543 PyObject *resultobj = 0;
31544 wxWindow *arg1 = (wxWindow *) 0 ;
31545 wxRect *arg2 = 0 ;
31546 int arg3 = (int) wxSIZE_AUTO ;
31547 void *argp1 = 0 ;
31548 int res1 = 0 ;
31549 wxRect temp2 ;
31550 int val3 ;
31551 int ecode3 = 0 ;
31552 PyObject * obj0 = 0 ;
31553 PyObject * obj1 = 0 ;
31554 PyObject * obj2 = 0 ;
31555 char * kwnames[] = {
31556 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
31557 };
31558
31559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31561 if (!SWIG_IsOK(res1)) {
31562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31563 }
31564 arg1 = reinterpret_cast< wxWindow * >(argp1);
31565 {
31566 arg2 = &temp2;
31567 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31568 }
31569 if (obj2) {
31570 ecode3 = SWIG_AsVal_int(obj2, &val3);
31571 if (!SWIG_IsOK(ecode3)) {
31572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
31573 }
31574 arg3 = static_cast< int >(val3);
31575 }
31576 {
31577 PyThreadState* __tstate = wxPyBeginAllowThreads();
31578 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31579 wxPyEndAllowThreads(__tstate);
31580 if (PyErr_Occurred()) SWIG_fail;
31581 }
31582 resultobj = SWIG_Py_Void();
31583 return resultobj;
31584 fail:
31585 return NULL;
31586 }
31587
31588
31589 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31590 PyObject *resultobj = 0;
31591 wxWindow *arg1 = (wxWindow *) 0 ;
31592 int arg2 ;
31593 int arg3 ;
31594 void *argp1 = 0 ;
31595 int res1 = 0 ;
31596 int val2 ;
31597 int ecode2 = 0 ;
31598 int val3 ;
31599 int ecode3 = 0 ;
31600 PyObject * obj0 = 0 ;
31601 PyObject * obj1 = 0 ;
31602 PyObject * obj2 = 0 ;
31603 char * kwnames[] = {
31604 (char *) "self",(char *) "width",(char *) "height", NULL
31605 };
31606
31607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31609 if (!SWIG_IsOK(res1)) {
31610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31611 }
31612 arg1 = reinterpret_cast< wxWindow * >(argp1);
31613 ecode2 = SWIG_AsVal_int(obj1, &val2);
31614 if (!SWIG_IsOK(ecode2)) {
31615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31616 }
31617 arg2 = static_cast< int >(val2);
31618 ecode3 = SWIG_AsVal_int(obj2, &val3);
31619 if (!SWIG_IsOK(ecode3)) {
31620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31621 }
31622 arg3 = static_cast< int >(val3);
31623 {
31624 PyThreadState* __tstate = wxPyBeginAllowThreads();
31625 (arg1)->SetSize(arg2,arg3);
31626 wxPyEndAllowThreads(__tstate);
31627 if (PyErr_Occurred()) SWIG_fail;
31628 }
31629 resultobj = SWIG_Py_Void();
31630 return resultobj;
31631 fail:
31632 return NULL;
31633 }
31634
31635
31636 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31637 PyObject *resultobj = 0;
31638 wxWindow *arg1 = (wxWindow *) 0 ;
31639 wxPoint *arg2 = 0 ;
31640 int arg3 = (int) wxSIZE_USE_EXISTING ;
31641 void *argp1 = 0 ;
31642 int res1 = 0 ;
31643 wxPoint temp2 ;
31644 int val3 ;
31645 int ecode3 = 0 ;
31646 PyObject * obj0 = 0 ;
31647 PyObject * obj1 = 0 ;
31648 PyObject * obj2 = 0 ;
31649 char * kwnames[] = {
31650 (char *) "self",(char *) "pt",(char *) "flags", NULL
31651 };
31652
31653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31655 if (!SWIG_IsOK(res1)) {
31656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31657 }
31658 arg1 = reinterpret_cast< wxWindow * >(argp1);
31659 {
31660 arg2 = &temp2;
31661 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31662 }
31663 if (obj2) {
31664 ecode3 = SWIG_AsVal_int(obj2, &val3);
31665 if (!SWIG_IsOK(ecode3)) {
31666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31667 }
31668 arg3 = static_cast< int >(val3);
31669 }
31670 {
31671 PyThreadState* __tstate = wxPyBeginAllowThreads();
31672 (arg1)->Move((wxPoint const &)*arg2,arg3);
31673 wxPyEndAllowThreads(__tstate);
31674 if (PyErr_Occurred()) SWIG_fail;
31675 }
31676 resultobj = SWIG_Py_Void();
31677 return resultobj;
31678 fail:
31679 return NULL;
31680 }
31681
31682
31683 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31684 PyObject *resultobj = 0;
31685 wxWindow *arg1 = (wxWindow *) 0 ;
31686 int arg2 ;
31687 int arg3 ;
31688 int arg4 = (int) wxSIZE_USE_EXISTING ;
31689 void *argp1 = 0 ;
31690 int res1 = 0 ;
31691 int val2 ;
31692 int ecode2 = 0 ;
31693 int val3 ;
31694 int ecode3 = 0 ;
31695 int val4 ;
31696 int ecode4 = 0 ;
31697 PyObject * obj0 = 0 ;
31698 PyObject * obj1 = 0 ;
31699 PyObject * obj2 = 0 ;
31700 PyObject * obj3 = 0 ;
31701 char * kwnames[] = {
31702 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31703 };
31704
31705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31707 if (!SWIG_IsOK(res1)) {
31708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31709 }
31710 arg1 = reinterpret_cast< wxWindow * >(argp1);
31711 ecode2 = SWIG_AsVal_int(obj1, &val2);
31712 if (!SWIG_IsOK(ecode2)) {
31713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31714 }
31715 arg2 = static_cast< int >(val2);
31716 ecode3 = SWIG_AsVal_int(obj2, &val3);
31717 if (!SWIG_IsOK(ecode3)) {
31718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31719 }
31720 arg3 = static_cast< int >(val3);
31721 if (obj3) {
31722 ecode4 = SWIG_AsVal_int(obj3, &val4);
31723 if (!SWIG_IsOK(ecode4)) {
31724 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31725 }
31726 arg4 = static_cast< int >(val4);
31727 }
31728 {
31729 PyThreadState* __tstate = wxPyBeginAllowThreads();
31730 (arg1)->Move(arg2,arg3,arg4);
31731 wxPyEndAllowThreads(__tstate);
31732 if (PyErr_Occurred()) SWIG_fail;
31733 }
31734 resultobj = SWIG_Py_Void();
31735 return resultobj;
31736 fail:
31737 return NULL;
31738 }
31739
31740
31741 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31742 PyObject *resultobj = 0;
31743 wxWindow *arg1 = (wxWindow *) 0 ;
31744 wxSize const &arg2_defvalue = wxDefaultSize ;
31745 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31746 void *argp1 = 0 ;
31747 int res1 = 0 ;
31748 wxSize temp2 ;
31749 PyObject * obj0 = 0 ;
31750 PyObject * obj1 = 0 ;
31751 char * kwnames[] = {
31752 (char *) "self",(char *) "size", NULL
31753 };
31754
31755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31757 if (!SWIG_IsOK(res1)) {
31758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31759 }
31760 arg1 = reinterpret_cast< wxWindow * >(argp1);
31761 if (obj1) {
31762 {
31763 arg2 = &temp2;
31764 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31765 }
31766 }
31767 {
31768 PyThreadState* __tstate = wxPyBeginAllowThreads();
31769 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31770 wxPyEndAllowThreads(__tstate);
31771 if (PyErr_Occurred()) SWIG_fail;
31772 }
31773 resultobj = SWIG_Py_Void();
31774 return resultobj;
31775 fail:
31776 return NULL;
31777 }
31778
31779
31780 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31781 PyObject *resultobj = 0;
31782 wxWindow *arg1 = (wxWindow *) 0 ;
31783 void *argp1 = 0 ;
31784 int res1 = 0 ;
31785 PyObject *swig_obj[1] ;
31786
31787 if (!args) SWIG_fail;
31788 swig_obj[0] = args;
31789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31790 if (!SWIG_IsOK(res1)) {
31791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31792 }
31793 arg1 = reinterpret_cast< wxWindow * >(argp1);
31794 {
31795 PyThreadState* __tstate = wxPyBeginAllowThreads();
31796 (arg1)->Raise();
31797 wxPyEndAllowThreads(__tstate);
31798 if (PyErr_Occurred()) SWIG_fail;
31799 }
31800 resultobj = SWIG_Py_Void();
31801 return resultobj;
31802 fail:
31803 return NULL;
31804 }
31805
31806
31807 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31808 PyObject *resultobj = 0;
31809 wxWindow *arg1 = (wxWindow *) 0 ;
31810 void *argp1 = 0 ;
31811 int res1 = 0 ;
31812 PyObject *swig_obj[1] ;
31813
31814 if (!args) SWIG_fail;
31815 swig_obj[0] = args;
31816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31817 if (!SWIG_IsOK(res1)) {
31818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31819 }
31820 arg1 = reinterpret_cast< wxWindow * >(argp1);
31821 {
31822 PyThreadState* __tstate = wxPyBeginAllowThreads();
31823 (arg1)->Lower();
31824 wxPyEndAllowThreads(__tstate);
31825 if (PyErr_Occurred()) SWIG_fail;
31826 }
31827 resultobj = SWIG_Py_Void();
31828 return resultobj;
31829 fail:
31830 return NULL;
31831 }
31832
31833
31834 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31835 PyObject *resultobj = 0;
31836 wxWindow *arg1 = (wxWindow *) 0 ;
31837 wxSize *arg2 = 0 ;
31838 void *argp1 = 0 ;
31839 int res1 = 0 ;
31840 wxSize temp2 ;
31841 PyObject * obj0 = 0 ;
31842 PyObject * obj1 = 0 ;
31843 char * kwnames[] = {
31844 (char *) "self",(char *) "size", NULL
31845 };
31846
31847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31849 if (!SWIG_IsOK(res1)) {
31850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31851 }
31852 arg1 = reinterpret_cast< wxWindow * >(argp1);
31853 {
31854 arg2 = &temp2;
31855 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31856 }
31857 {
31858 PyThreadState* __tstate = wxPyBeginAllowThreads();
31859 (arg1)->SetClientSize((wxSize const &)*arg2);
31860 wxPyEndAllowThreads(__tstate);
31861 if (PyErr_Occurred()) SWIG_fail;
31862 }
31863 resultobj = SWIG_Py_Void();
31864 return resultobj;
31865 fail:
31866 return NULL;
31867 }
31868
31869
31870 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31871 PyObject *resultobj = 0;
31872 wxWindow *arg1 = (wxWindow *) 0 ;
31873 int arg2 ;
31874 int arg3 ;
31875 void *argp1 = 0 ;
31876 int res1 = 0 ;
31877 int val2 ;
31878 int ecode2 = 0 ;
31879 int val3 ;
31880 int ecode3 = 0 ;
31881 PyObject * obj0 = 0 ;
31882 PyObject * obj1 = 0 ;
31883 PyObject * obj2 = 0 ;
31884 char * kwnames[] = {
31885 (char *) "self",(char *) "width",(char *) "height", NULL
31886 };
31887
31888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31890 if (!SWIG_IsOK(res1)) {
31891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31892 }
31893 arg1 = reinterpret_cast< wxWindow * >(argp1);
31894 ecode2 = SWIG_AsVal_int(obj1, &val2);
31895 if (!SWIG_IsOK(ecode2)) {
31896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31897 }
31898 arg2 = static_cast< int >(val2);
31899 ecode3 = SWIG_AsVal_int(obj2, &val3);
31900 if (!SWIG_IsOK(ecode3)) {
31901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31902 }
31903 arg3 = static_cast< int >(val3);
31904 {
31905 PyThreadState* __tstate = wxPyBeginAllowThreads();
31906 (arg1)->SetClientSize(arg2,arg3);
31907 wxPyEndAllowThreads(__tstate);
31908 if (PyErr_Occurred()) SWIG_fail;
31909 }
31910 resultobj = SWIG_Py_Void();
31911 return resultobj;
31912 fail:
31913 return NULL;
31914 }
31915
31916
31917 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31918 PyObject *resultobj = 0;
31919 wxWindow *arg1 = (wxWindow *) 0 ;
31920 wxRect *arg2 = 0 ;
31921 void *argp1 = 0 ;
31922 int res1 = 0 ;
31923 wxRect temp2 ;
31924 PyObject * obj0 = 0 ;
31925 PyObject * obj1 = 0 ;
31926 char * kwnames[] = {
31927 (char *) "self",(char *) "rect", NULL
31928 };
31929
31930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31932 if (!SWIG_IsOK(res1)) {
31933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31934 }
31935 arg1 = reinterpret_cast< wxWindow * >(argp1);
31936 {
31937 arg2 = &temp2;
31938 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31939 }
31940 {
31941 PyThreadState* __tstate = wxPyBeginAllowThreads();
31942 (arg1)->SetClientSize((wxRect const &)*arg2);
31943 wxPyEndAllowThreads(__tstate);
31944 if (PyErr_Occurred()) SWIG_fail;
31945 }
31946 resultobj = SWIG_Py_Void();
31947 return resultobj;
31948 fail:
31949 return NULL;
31950 }
31951
31952
31953 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31954 PyObject *resultobj = 0;
31955 wxWindow *arg1 = (wxWindow *) 0 ;
31956 wxPoint result;
31957 void *argp1 = 0 ;
31958 int res1 = 0 ;
31959 PyObject *swig_obj[1] ;
31960
31961 if (!args) SWIG_fail;
31962 swig_obj[0] = args;
31963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31964 if (!SWIG_IsOK(res1)) {
31965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31966 }
31967 arg1 = reinterpret_cast< wxWindow * >(argp1);
31968 {
31969 PyThreadState* __tstate = wxPyBeginAllowThreads();
31970 result = ((wxWindow const *)arg1)->GetPosition();
31971 wxPyEndAllowThreads(__tstate);
31972 if (PyErr_Occurred()) SWIG_fail;
31973 }
31974 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31975 return resultobj;
31976 fail:
31977 return NULL;
31978 }
31979
31980
31981 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31982 PyObject *resultobj = 0;
31983 wxWindow *arg1 = (wxWindow *) 0 ;
31984 int *arg2 = (int *) 0 ;
31985 int *arg3 = (int *) 0 ;
31986 void *argp1 = 0 ;
31987 int res1 = 0 ;
31988 int temp2 ;
31989 int res2 = SWIG_TMPOBJ ;
31990 int temp3 ;
31991 int res3 = SWIG_TMPOBJ ;
31992 PyObject *swig_obj[1] ;
31993
31994 arg2 = &temp2;
31995 arg3 = &temp3;
31996 if (!args) SWIG_fail;
31997 swig_obj[0] = args;
31998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31999 if (!SWIG_IsOK(res1)) {
32000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32001 }
32002 arg1 = reinterpret_cast< wxWindow * >(argp1);
32003 {
32004 PyThreadState* __tstate = wxPyBeginAllowThreads();
32005 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
32006 wxPyEndAllowThreads(__tstate);
32007 if (PyErr_Occurred()) SWIG_fail;
32008 }
32009 resultobj = SWIG_Py_Void();
32010 if (SWIG_IsTmpObj(res2)) {
32011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32012 } else {
32013 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32015 }
32016 if (SWIG_IsTmpObj(res3)) {
32017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32018 } else {
32019 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32020 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32021 }
32022 return resultobj;
32023 fail:
32024 return NULL;
32025 }
32026
32027
32028 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32029 PyObject *resultobj = 0;
32030 wxWindow *arg1 = (wxWindow *) 0 ;
32031 wxPoint result;
32032 void *argp1 = 0 ;
32033 int res1 = 0 ;
32034 PyObject *swig_obj[1] ;
32035
32036 if (!args) SWIG_fail;
32037 swig_obj[0] = args;
32038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32039 if (!SWIG_IsOK(res1)) {
32040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
32041 }
32042 arg1 = reinterpret_cast< wxWindow * >(argp1);
32043 {
32044 PyThreadState* __tstate = wxPyBeginAllowThreads();
32045 result = ((wxWindow const *)arg1)->GetScreenPosition();
32046 wxPyEndAllowThreads(__tstate);
32047 if (PyErr_Occurred()) SWIG_fail;
32048 }
32049 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32050 return resultobj;
32051 fail:
32052 return NULL;
32053 }
32054
32055
32056 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32057 PyObject *resultobj = 0;
32058 wxWindow *arg1 = (wxWindow *) 0 ;
32059 int *arg2 = (int *) 0 ;
32060 int *arg3 = (int *) 0 ;
32061 void *argp1 = 0 ;
32062 int res1 = 0 ;
32063 int temp2 ;
32064 int res2 = SWIG_TMPOBJ ;
32065 int temp3 ;
32066 int res3 = SWIG_TMPOBJ ;
32067 PyObject *swig_obj[1] ;
32068
32069 arg2 = &temp2;
32070 arg3 = &temp3;
32071 if (!args) SWIG_fail;
32072 swig_obj[0] = args;
32073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32074 if (!SWIG_IsOK(res1)) {
32075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32076 }
32077 arg1 = reinterpret_cast< wxWindow * >(argp1);
32078 {
32079 PyThreadState* __tstate = wxPyBeginAllowThreads();
32080 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
32081 wxPyEndAllowThreads(__tstate);
32082 if (PyErr_Occurred()) SWIG_fail;
32083 }
32084 resultobj = SWIG_Py_Void();
32085 if (SWIG_IsTmpObj(res2)) {
32086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32087 } else {
32088 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32090 }
32091 if (SWIG_IsTmpObj(res3)) {
32092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32093 } else {
32094 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32096 }
32097 return resultobj;
32098 fail:
32099 return NULL;
32100 }
32101
32102
32103 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32104 PyObject *resultobj = 0;
32105 wxWindow *arg1 = (wxWindow *) 0 ;
32106 wxRect result;
32107 void *argp1 = 0 ;
32108 int res1 = 0 ;
32109 PyObject *swig_obj[1] ;
32110
32111 if (!args) SWIG_fail;
32112 swig_obj[0] = args;
32113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32114 if (!SWIG_IsOK(res1)) {
32115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32116 }
32117 arg1 = reinterpret_cast< wxWindow * >(argp1);
32118 {
32119 PyThreadState* __tstate = wxPyBeginAllowThreads();
32120 result = ((wxWindow const *)arg1)->GetScreenRect();
32121 wxPyEndAllowThreads(__tstate);
32122 if (PyErr_Occurred()) SWIG_fail;
32123 }
32124 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32125 return resultobj;
32126 fail:
32127 return NULL;
32128 }
32129
32130
32131 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32132 PyObject *resultobj = 0;
32133 wxWindow *arg1 = (wxWindow *) 0 ;
32134 wxSize result;
32135 void *argp1 = 0 ;
32136 int res1 = 0 ;
32137 PyObject *swig_obj[1] ;
32138
32139 if (!args) SWIG_fail;
32140 swig_obj[0] = args;
32141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32142 if (!SWIG_IsOK(res1)) {
32143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32144 }
32145 arg1 = reinterpret_cast< wxWindow * >(argp1);
32146 {
32147 PyThreadState* __tstate = wxPyBeginAllowThreads();
32148 result = ((wxWindow const *)arg1)->GetSize();
32149 wxPyEndAllowThreads(__tstate);
32150 if (PyErr_Occurred()) SWIG_fail;
32151 }
32152 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32153 return resultobj;
32154 fail:
32155 return NULL;
32156 }
32157
32158
32159 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32160 PyObject *resultobj = 0;
32161 wxWindow *arg1 = (wxWindow *) 0 ;
32162 int *arg2 = (int *) 0 ;
32163 int *arg3 = (int *) 0 ;
32164 void *argp1 = 0 ;
32165 int res1 = 0 ;
32166 int temp2 ;
32167 int res2 = SWIG_TMPOBJ ;
32168 int temp3 ;
32169 int res3 = SWIG_TMPOBJ ;
32170 PyObject *swig_obj[1] ;
32171
32172 arg2 = &temp2;
32173 arg3 = &temp3;
32174 if (!args) SWIG_fail;
32175 swig_obj[0] = args;
32176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32177 if (!SWIG_IsOK(res1)) {
32178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32179 }
32180 arg1 = reinterpret_cast< wxWindow * >(argp1);
32181 {
32182 PyThreadState* __tstate = wxPyBeginAllowThreads();
32183 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
32184 wxPyEndAllowThreads(__tstate);
32185 if (PyErr_Occurred()) SWIG_fail;
32186 }
32187 resultobj = SWIG_Py_Void();
32188 if (SWIG_IsTmpObj(res2)) {
32189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32190 } else {
32191 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32193 }
32194 if (SWIG_IsTmpObj(res3)) {
32195 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32196 } else {
32197 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32198 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32199 }
32200 return resultobj;
32201 fail:
32202 return NULL;
32203 }
32204
32205
32206 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32207 PyObject *resultobj = 0;
32208 wxWindow *arg1 = (wxWindow *) 0 ;
32209 wxRect result;
32210 void *argp1 = 0 ;
32211 int res1 = 0 ;
32212 PyObject *swig_obj[1] ;
32213
32214 if (!args) SWIG_fail;
32215 swig_obj[0] = args;
32216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32217 if (!SWIG_IsOK(res1)) {
32218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32219 }
32220 arg1 = reinterpret_cast< wxWindow * >(argp1);
32221 {
32222 PyThreadState* __tstate = wxPyBeginAllowThreads();
32223 result = ((wxWindow const *)arg1)->GetRect();
32224 wxPyEndAllowThreads(__tstate);
32225 if (PyErr_Occurred()) SWIG_fail;
32226 }
32227 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32228 return resultobj;
32229 fail:
32230 return NULL;
32231 }
32232
32233
32234 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32235 PyObject *resultobj = 0;
32236 wxWindow *arg1 = (wxWindow *) 0 ;
32237 wxSize result;
32238 void *argp1 = 0 ;
32239 int res1 = 0 ;
32240 PyObject *swig_obj[1] ;
32241
32242 if (!args) SWIG_fail;
32243 swig_obj[0] = args;
32244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32245 if (!SWIG_IsOK(res1)) {
32246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32247 }
32248 arg1 = reinterpret_cast< wxWindow * >(argp1);
32249 {
32250 PyThreadState* __tstate = wxPyBeginAllowThreads();
32251 result = ((wxWindow const *)arg1)->GetClientSize();
32252 wxPyEndAllowThreads(__tstate);
32253 if (PyErr_Occurred()) SWIG_fail;
32254 }
32255 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32256 return resultobj;
32257 fail:
32258 return NULL;
32259 }
32260
32261
32262 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32263 PyObject *resultobj = 0;
32264 wxWindow *arg1 = (wxWindow *) 0 ;
32265 int *arg2 = (int *) 0 ;
32266 int *arg3 = (int *) 0 ;
32267 void *argp1 = 0 ;
32268 int res1 = 0 ;
32269 int temp2 ;
32270 int res2 = SWIG_TMPOBJ ;
32271 int temp3 ;
32272 int res3 = SWIG_TMPOBJ ;
32273 PyObject *swig_obj[1] ;
32274
32275 arg2 = &temp2;
32276 arg3 = &temp3;
32277 if (!args) SWIG_fail;
32278 swig_obj[0] = args;
32279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32280 if (!SWIG_IsOK(res1)) {
32281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32282 }
32283 arg1 = reinterpret_cast< wxWindow * >(argp1);
32284 {
32285 PyThreadState* __tstate = wxPyBeginAllowThreads();
32286 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
32287 wxPyEndAllowThreads(__tstate);
32288 if (PyErr_Occurred()) SWIG_fail;
32289 }
32290 resultobj = SWIG_Py_Void();
32291 if (SWIG_IsTmpObj(res2)) {
32292 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32293 } else {
32294 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32295 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32296 }
32297 if (SWIG_IsTmpObj(res3)) {
32298 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32299 } else {
32300 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32301 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32302 }
32303 return resultobj;
32304 fail:
32305 return NULL;
32306 }
32307
32308
32309 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32310 PyObject *resultobj = 0;
32311 wxWindow *arg1 = (wxWindow *) 0 ;
32312 wxPoint result;
32313 void *argp1 = 0 ;
32314 int res1 = 0 ;
32315 PyObject *swig_obj[1] ;
32316
32317 if (!args) SWIG_fail;
32318 swig_obj[0] = args;
32319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32320 if (!SWIG_IsOK(res1)) {
32321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
32322 }
32323 arg1 = reinterpret_cast< wxWindow * >(argp1);
32324 {
32325 PyThreadState* __tstate = wxPyBeginAllowThreads();
32326 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
32327 wxPyEndAllowThreads(__tstate);
32328 if (PyErr_Occurred()) SWIG_fail;
32329 }
32330 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32331 return resultobj;
32332 fail:
32333 return NULL;
32334 }
32335
32336
32337 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32338 PyObject *resultobj = 0;
32339 wxWindow *arg1 = (wxWindow *) 0 ;
32340 wxRect result;
32341 void *argp1 = 0 ;
32342 int res1 = 0 ;
32343 PyObject *swig_obj[1] ;
32344
32345 if (!args) SWIG_fail;
32346 swig_obj[0] = args;
32347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32348 if (!SWIG_IsOK(res1)) {
32349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32350 }
32351 arg1 = reinterpret_cast< wxWindow * >(argp1);
32352 {
32353 PyThreadState* __tstate = wxPyBeginAllowThreads();
32354 result = ((wxWindow const *)arg1)->GetClientRect();
32355 wxPyEndAllowThreads(__tstate);
32356 if (PyErr_Occurred()) SWIG_fail;
32357 }
32358 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32359 return resultobj;
32360 fail:
32361 return NULL;
32362 }
32363
32364
32365 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32366 PyObject *resultobj = 0;
32367 wxWindow *arg1 = (wxWindow *) 0 ;
32368 wxSize result;
32369 void *argp1 = 0 ;
32370 int res1 = 0 ;
32371 PyObject *swig_obj[1] ;
32372
32373 if (!args) SWIG_fail;
32374 swig_obj[0] = args;
32375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32376 if (!SWIG_IsOK(res1)) {
32377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32378 }
32379 arg1 = reinterpret_cast< wxWindow * >(argp1);
32380 {
32381 PyThreadState* __tstate = wxPyBeginAllowThreads();
32382 result = ((wxWindow const *)arg1)->GetBestSize();
32383 wxPyEndAllowThreads(__tstate);
32384 if (PyErr_Occurred()) SWIG_fail;
32385 }
32386 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32387 return resultobj;
32388 fail:
32389 return NULL;
32390 }
32391
32392
32393 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32394 PyObject *resultobj = 0;
32395 wxWindow *arg1 = (wxWindow *) 0 ;
32396 int *arg2 = (int *) 0 ;
32397 int *arg3 = (int *) 0 ;
32398 void *argp1 = 0 ;
32399 int res1 = 0 ;
32400 int temp2 ;
32401 int res2 = SWIG_TMPOBJ ;
32402 int temp3 ;
32403 int res3 = SWIG_TMPOBJ ;
32404 PyObject *swig_obj[1] ;
32405
32406 arg2 = &temp2;
32407 arg3 = &temp3;
32408 if (!args) SWIG_fail;
32409 swig_obj[0] = args;
32410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32411 if (!SWIG_IsOK(res1)) {
32412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32413 }
32414 arg1 = reinterpret_cast< wxWindow * >(argp1);
32415 {
32416 PyThreadState* __tstate = wxPyBeginAllowThreads();
32417 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
32418 wxPyEndAllowThreads(__tstate);
32419 if (PyErr_Occurred()) SWIG_fail;
32420 }
32421 resultobj = SWIG_Py_Void();
32422 if (SWIG_IsTmpObj(res2)) {
32423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32424 } else {
32425 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32426 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32427 }
32428 if (SWIG_IsTmpObj(res3)) {
32429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32430 } else {
32431 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32432 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32433 }
32434 return resultobj;
32435 fail:
32436 return NULL;
32437 }
32438
32439
32440 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32441 PyObject *resultobj = 0;
32442 wxWindow *arg1 = (wxWindow *) 0 ;
32443 void *argp1 = 0 ;
32444 int res1 = 0 ;
32445 PyObject *swig_obj[1] ;
32446
32447 if (!args) SWIG_fail;
32448 swig_obj[0] = args;
32449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32450 if (!SWIG_IsOK(res1)) {
32451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32452 }
32453 arg1 = reinterpret_cast< wxWindow * >(argp1);
32454 {
32455 PyThreadState* __tstate = wxPyBeginAllowThreads();
32456 (arg1)->InvalidateBestSize();
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_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32468 PyObject *resultobj = 0;
32469 wxWindow *arg1 = (wxWindow *) 0 ;
32470 wxSize *arg2 = 0 ;
32471 void *argp1 = 0 ;
32472 int res1 = 0 ;
32473 wxSize temp2 ;
32474 PyObject * obj0 = 0 ;
32475 PyObject * obj1 = 0 ;
32476 char * kwnames[] = {
32477 (char *) "self",(char *) "size", NULL
32478 };
32479
32480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
32481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32482 if (!SWIG_IsOK(res1)) {
32483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32484 }
32485 arg1 = reinterpret_cast< wxWindow * >(argp1);
32486 {
32487 arg2 = &temp2;
32488 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32489 }
32490 {
32491 PyThreadState* __tstate = wxPyBeginAllowThreads();
32492 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
32493 wxPyEndAllowThreads(__tstate);
32494 if (PyErr_Occurred()) SWIG_fail;
32495 }
32496 resultobj = SWIG_Py_Void();
32497 return resultobj;
32498 fail:
32499 return NULL;
32500 }
32501
32502
32503 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32504 PyObject *resultobj = 0;
32505 wxWindow *arg1 = (wxWindow *) 0 ;
32506 wxSize result;
32507 void *argp1 = 0 ;
32508 int res1 = 0 ;
32509 PyObject *swig_obj[1] ;
32510
32511 if (!args) SWIG_fail;
32512 swig_obj[0] = args;
32513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32514 if (!SWIG_IsOK(res1)) {
32515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32516 }
32517 arg1 = reinterpret_cast< wxWindow * >(argp1);
32518 {
32519 PyThreadState* __tstate = wxPyBeginAllowThreads();
32520 result = ((wxWindow const *)arg1)->GetBestFittingSize();
32521 wxPyEndAllowThreads(__tstate);
32522 if (PyErr_Occurred()) SWIG_fail;
32523 }
32524 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32525 return resultobj;
32526 fail:
32527 return NULL;
32528 }
32529
32530
32531 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32532 PyObject *resultobj = 0;
32533 wxWindow *arg1 = (wxWindow *) 0 ;
32534 wxSize result;
32535 void *argp1 = 0 ;
32536 int res1 = 0 ;
32537 PyObject *swig_obj[1] ;
32538
32539 if (!args) SWIG_fail;
32540 swig_obj[0] = args;
32541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32542 if (!SWIG_IsOK(res1)) {
32543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32544 }
32545 arg1 = reinterpret_cast< wxWindow * >(argp1);
32546 {
32547 PyThreadState* __tstate = wxPyBeginAllowThreads();
32548 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
32549 wxPyEndAllowThreads(__tstate);
32550 if (PyErr_Occurred()) SWIG_fail;
32551 }
32552 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32553 return resultobj;
32554 fail:
32555 return NULL;
32556 }
32557
32558
32559 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32560 PyObject *resultobj = 0;
32561 wxWindow *arg1 = (wxWindow *) 0 ;
32562 int arg2 = (int) wxBOTH ;
32563 void *argp1 = 0 ;
32564 int res1 = 0 ;
32565 int val2 ;
32566 int ecode2 = 0 ;
32567 PyObject * obj0 = 0 ;
32568 PyObject * obj1 = 0 ;
32569 char * kwnames[] = {
32570 (char *) "self",(char *) "direction", NULL
32571 };
32572
32573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
32574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32575 if (!SWIG_IsOK(res1)) {
32576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32577 }
32578 arg1 = reinterpret_cast< wxWindow * >(argp1);
32579 if (obj1) {
32580 ecode2 = SWIG_AsVal_int(obj1, &val2);
32581 if (!SWIG_IsOK(ecode2)) {
32582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32583 }
32584 arg2 = static_cast< int >(val2);
32585 }
32586 {
32587 PyThreadState* __tstate = wxPyBeginAllowThreads();
32588 (arg1)->Center(arg2);
32589 wxPyEndAllowThreads(__tstate);
32590 if (PyErr_Occurred()) SWIG_fail;
32591 }
32592 resultobj = SWIG_Py_Void();
32593 return resultobj;
32594 fail:
32595 return NULL;
32596 }
32597
32598
32599 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32600 PyObject *resultobj = 0;
32601 wxWindow *arg1 = (wxWindow *) 0 ;
32602 int arg2 = (int) wxBOTH ;
32603 void *argp1 = 0 ;
32604 int res1 = 0 ;
32605 int val2 ;
32606 int ecode2 = 0 ;
32607 PyObject * obj0 = 0 ;
32608 PyObject * obj1 = 0 ;
32609 char * kwnames[] = {
32610 (char *) "self",(char *) "dir", NULL
32611 };
32612
32613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32615 if (!SWIG_IsOK(res1)) {
32616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32617 }
32618 arg1 = reinterpret_cast< wxWindow * >(argp1);
32619 if (obj1) {
32620 ecode2 = SWIG_AsVal_int(obj1, &val2);
32621 if (!SWIG_IsOK(ecode2)) {
32622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32623 }
32624 arg2 = static_cast< int >(val2);
32625 }
32626 {
32627 PyThreadState* __tstate = wxPyBeginAllowThreads();
32628 (arg1)->CenterOnParent(arg2);
32629 wxPyEndAllowThreads(__tstate);
32630 if (PyErr_Occurred()) SWIG_fail;
32631 }
32632 resultobj = SWIG_Py_Void();
32633 return resultobj;
32634 fail:
32635 return NULL;
32636 }
32637
32638
32639 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32640 PyObject *resultobj = 0;
32641 wxWindow *arg1 = (wxWindow *) 0 ;
32642 void *argp1 = 0 ;
32643 int res1 = 0 ;
32644 PyObject *swig_obj[1] ;
32645
32646 if (!args) SWIG_fail;
32647 swig_obj[0] = args;
32648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32649 if (!SWIG_IsOK(res1)) {
32650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32651 }
32652 arg1 = reinterpret_cast< wxWindow * >(argp1);
32653 {
32654 PyThreadState* __tstate = wxPyBeginAllowThreads();
32655 (arg1)->Fit();
32656 wxPyEndAllowThreads(__tstate);
32657 if (PyErr_Occurred()) SWIG_fail;
32658 }
32659 resultobj = SWIG_Py_Void();
32660 return resultobj;
32661 fail:
32662 return NULL;
32663 }
32664
32665
32666 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32667 PyObject *resultobj = 0;
32668 wxWindow *arg1 = (wxWindow *) 0 ;
32669 void *argp1 = 0 ;
32670 int res1 = 0 ;
32671 PyObject *swig_obj[1] ;
32672
32673 if (!args) SWIG_fail;
32674 swig_obj[0] = args;
32675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32676 if (!SWIG_IsOK(res1)) {
32677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32678 }
32679 arg1 = reinterpret_cast< wxWindow * >(argp1);
32680 {
32681 PyThreadState* __tstate = wxPyBeginAllowThreads();
32682 (arg1)->FitInside();
32683 wxPyEndAllowThreads(__tstate);
32684 if (PyErr_Occurred()) SWIG_fail;
32685 }
32686 resultobj = SWIG_Py_Void();
32687 return resultobj;
32688 fail:
32689 return NULL;
32690 }
32691
32692
32693 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32694 PyObject *resultobj = 0;
32695 wxWindow *arg1 = (wxWindow *) 0 ;
32696 int arg2 ;
32697 int arg3 ;
32698 int arg4 = (int) -1 ;
32699 int arg5 = (int) -1 ;
32700 int arg6 = (int) -1 ;
32701 int arg7 = (int) -1 ;
32702 void *argp1 = 0 ;
32703 int res1 = 0 ;
32704 int val2 ;
32705 int ecode2 = 0 ;
32706 int val3 ;
32707 int ecode3 = 0 ;
32708 int val4 ;
32709 int ecode4 = 0 ;
32710 int val5 ;
32711 int ecode5 = 0 ;
32712 int val6 ;
32713 int ecode6 = 0 ;
32714 int val7 ;
32715 int ecode7 = 0 ;
32716 PyObject * obj0 = 0 ;
32717 PyObject * obj1 = 0 ;
32718 PyObject * obj2 = 0 ;
32719 PyObject * obj3 = 0 ;
32720 PyObject * obj4 = 0 ;
32721 PyObject * obj5 = 0 ;
32722 PyObject * obj6 = 0 ;
32723 char * kwnames[] = {
32724 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32725 };
32726
32727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32729 if (!SWIG_IsOK(res1)) {
32730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32731 }
32732 arg1 = reinterpret_cast< wxWindow * >(argp1);
32733 ecode2 = SWIG_AsVal_int(obj1, &val2);
32734 if (!SWIG_IsOK(ecode2)) {
32735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32736 }
32737 arg2 = static_cast< int >(val2);
32738 ecode3 = SWIG_AsVal_int(obj2, &val3);
32739 if (!SWIG_IsOK(ecode3)) {
32740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32741 }
32742 arg3 = static_cast< int >(val3);
32743 if (obj3) {
32744 ecode4 = SWIG_AsVal_int(obj3, &val4);
32745 if (!SWIG_IsOK(ecode4)) {
32746 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32747 }
32748 arg4 = static_cast< int >(val4);
32749 }
32750 if (obj4) {
32751 ecode5 = SWIG_AsVal_int(obj4, &val5);
32752 if (!SWIG_IsOK(ecode5)) {
32753 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32754 }
32755 arg5 = static_cast< int >(val5);
32756 }
32757 if (obj5) {
32758 ecode6 = SWIG_AsVal_int(obj5, &val6);
32759 if (!SWIG_IsOK(ecode6)) {
32760 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32761 }
32762 arg6 = static_cast< int >(val6);
32763 }
32764 if (obj6) {
32765 ecode7 = SWIG_AsVal_int(obj6, &val7);
32766 if (!SWIG_IsOK(ecode7)) {
32767 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32768 }
32769 arg7 = static_cast< int >(val7);
32770 }
32771 {
32772 PyThreadState* __tstate = wxPyBeginAllowThreads();
32773 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32774 wxPyEndAllowThreads(__tstate);
32775 if (PyErr_Occurred()) SWIG_fail;
32776 }
32777 resultobj = SWIG_Py_Void();
32778 return resultobj;
32779 fail:
32780 return NULL;
32781 }
32782
32783
32784 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32785 PyObject *resultobj = 0;
32786 wxWindow *arg1 = (wxWindow *) 0 ;
32787 wxSize *arg2 = 0 ;
32788 wxSize const &arg3_defvalue = wxDefaultSize ;
32789 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32790 wxSize const &arg4_defvalue = wxDefaultSize ;
32791 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32792 void *argp1 = 0 ;
32793 int res1 = 0 ;
32794 wxSize temp2 ;
32795 wxSize temp3 ;
32796 wxSize temp4 ;
32797 PyObject * obj0 = 0 ;
32798 PyObject * obj1 = 0 ;
32799 PyObject * obj2 = 0 ;
32800 PyObject * obj3 = 0 ;
32801 char * kwnames[] = {
32802 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32803 };
32804
32805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32807 if (!SWIG_IsOK(res1)) {
32808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32809 }
32810 arg1 = reinterpret_cast< wxWindow * >(argp1);
32811 {
32812 arg2 = &temp2;
32813 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32814 }
32815 if (obj2) {
32816 {
32817 arg3 = &temp3;
32818 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32819 }
32820 }
32821 if (obj3) {
32822 {
32823 arg4 = &temp4;
32824 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32825 }
32826 }
32827 {
32828 PyThreadState* __tstate = wxPyBeginAllowThreads();
32829 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32830 wxPyEndAllowThreads(__tstate);
32831 if (PyErr_Occurred()) SWIG_fail;
32832 }
32833 resultobj = SWIG_Py_Void();
32834 return resultobj;
32835 fail:
32836 return NULL;
32837 }
32838
32839
32840 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32841 PyObject *resultobj = 0;
32842 wxWindow *arg1 = (wxWindow *) 0 ;
32843 int arg2 ;
32844 int arg3 ;
32845 int arg4 = (int) -1 ;
32846 int arg5 = (int) -1 ;
32847 void *argp1 = 0 ;
32848 int res1 = 0 ;
32849 int val2 ;
32850 int ecode2 = 0 ;
32851 int val3 ;
32852 int ecode3 = 0 ;
32853 int val4 ;
32854 int ecode4 = 0 ;
32855 int val5 ;
32856 int ecode5 = 0 ;
32857 PyObject * obj0 = 0 ;
32858 PyObject * obj1 = 0 ;
32859 PyObject * obj2 = 0 ;
32860 PyObject * obj3 = 0 ;
32861 PyObject * obj4 = 0 ;
32862 char * kwnames[] = {
32863 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32864 };
32865
32866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32868 if (!SWIG_IsOK(res1)) {
32869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32870 }
32871 arg1 = reinterpret_cast< wxWindow * >(argp1);
32872 ecode2 = SWIG_AsVal_int(obj1, &val2);
32873 if (!SWIG_IsOK(ecode2)) {
32874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32875 }
32876 arg2 = static_cast< int >(val2);
32877 ecode3 = SWIG_AsVal_int(obj2, &val3);
32878 if (!SWIG_IsOK(ecode3)) {
32879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32880 }
32881 arg3 = static_cast< int >(val3);
32882 if (obj3) {
32883 ecode4 = SWIG_AsVal_int(obj3, &val4);
32884 if (!SWIG_IsOK(ecode4)) {
32885 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32886 }
32887 arg4 = static_cast< int >(val4);
32888 }
32889 if (obj4) {
32890 ecode5 = SWIG_AsVal_int(obj4, &val5);
32891 if (!SWIG_IsOK(ecode5)) {
32892 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32893 }
32894 arg5 = static_cast< int >(val5);
32895 }
32896 {
32897 PyThreadState* __tstate = wxPyBeginAllowThreads();
32898 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32899 wxPyEndAllowThreads(__tstate);
32900 if (PyErr_Occurred()) SWIG_fail;
32901 }
32902 resultobj = SWIG_Py_Void();
32903 return resultobj;
32904 fail:
32905 return NULL;
32906 }
32907
32908
32909 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32910 PyObject *resultobj = 0;
32911 wxWindow *arg1 = (wxWindow *) 0 ;
32912 wxSize *arg2 = 0 ;
32913 wxSize const &arg3_defvalue = wxDefaultSize ;
32914 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32915 void *argp1 = 0 ;
32916 int res1 = 0 ;
32917 wxSize temp2 ;
32918 wxSize temp3 ;
32919 PyObject * obj0 = 0 ;
32920 PyObject * obj1 = 0 ;
32921 PyObject * obj2 = 0 ;
32922 char * kwnames[] = {
32923 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32924 };
32925
32926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32928 if (!SWIG_IsOK(res1)) {
32929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32930 }
32931 arg1 = reinterpret_cast< wxWindow * >(argp1);
32932 {
32933 arg2 = &temp2;
32934 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32935 }
32936 if (obj2) {
32937 {
32938 arg3 = &temp3;
32939 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32940 }
32941 }
32942 {
32943 PyThreadState* __tstate = wxPyBeginAllowThreads();
32944 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32945 wxPyEndAllowThreads(__tstate);
32946 if (PyErr_Occurred()) SWIG_fail;
32947 }
32948 resultobj = SWIG_Py_Void();
32949 return resultobj;
32950 fail:
32951 return NULL;
32952 }
32953
32954
32955 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32956 PyObject *resultobj = 0;
32957 wxWindow *arg1 = (wxWindow *) 0 ;
32958 wxSize result;
32959 void *argp1 = 0 ;
32960 int res1 = 0 ;
32961 PyObject *swig_obj[1] ;
32962
32963 if (!args) SWIG_fail;
32964 swig_obj[0] = args;
32965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32966 if (!SWIG_IsOK(res1)) {
32967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32968 }
32969 arg1 = reinterpret_cast< wxWindow * >(argp1);
32970 {
32971 PyThreadState* __tstate = wxPyBeginAllowThreads();
32972 result = ((wxWindow const *)arg1)->GetMaxSize();
32973 wxPyEndAllowThreads(__tstate);
32974 if (PyErr_Occurred()) SWIG_fail;
32975 }
32976 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32977 return resultobj;
32978 fail:
32979 return NULL;
32980 }
32981
32982
32983 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32984 PyObject *resultobj = 0;
32985 wxWindow *arg1 = (wxWindow *) 0 ;
32986 wxSize result;
32987 void *argp1 = 0 ;
32988 int res1 = 0 ;
32989 PyObject *swig_obj[1] ;
32990
32991 if (!args) SWIG_fail;
32992 swig_obj[0] = args;
32993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32994 if (!SWIG_IsOK(res1)) {
32995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32996 }
32997 arg1 = reinterpret_cast< wxWindow * >(argp1);
32998 {
32999 PyThreadState* __tstate = wxPyBeginAllowThreads();
33000 result = ((wxWindow const *)arg1)->GetMinSize();
33001 wxPyEndAllowThreads(__tstate);
33002 if (PyErr_Occurred()) SWIG_fail;
33003 }
33004 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33005 return resultobj;
33006 fail:
33007 return NULL;
33008 }
33009
33010
33011 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33012 PyObject *resultobj = 0;
33013 wxWindow *arg1 = (wxWindow *) 0 ;
33014 wxSize *arg2 = 0 ;
33015 void *argp1 = 0 ;
33016 int res1 = 0 ;
33017 wxSize temp2 ;
33018 PyObject * obj0 = 0 ;
33019 PyObject * obj1 = 0 ;
33020 char * kwnames[] = {
33021 (char *) "self",(char *) "minSize", NULL
33022 };
33023
33024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
33025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33026 if (!SWIG_IsOK(res1)) {
33027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33028 }
33029 arg1 = reinterpret_cast< wxWindow * >(argp1);
33030 {
33031 arg2 = &temp2;
33032 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33033 }
33034 {
33035 PyThreadState* __tstate = wxPyBeginAllowThreads();
33036 (arg1)->SetMinSize((wxSize const &)*arg2);
33037 wxPyEndAllowThreads(__tstate);
33038 if (PyErr_Occurred()) SWIG_fail;
33039 }
33040 resultobj = SWIG_Py_Void();
33041 return resultobj;
33042 fail:
33043 return NULL;
33044 }
33045
33046
33047 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33048 PyObject *resultobj = 0;
33049 wxWindow *arg1 = (wxWindow *) 0 ;
33050 wxSize *arg2 = 0 ;
33051 void *argp1 = 0 ;
33052 int res1 = 0 ;
33053 wxSize temp2 ;
33054 PyObject * obj0 = 0 ;
33055 PyObject * obj1 = 0 ;
33056 char * kwnames[] = {
33057 (char *) "self",(char *) "maxSize", NULL
33058 };
33059
33060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
33061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33062 if (!SWIG_IsOK(res1)) {
33063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33064 }
33065 arg1 = reinterpret_cast< wxWindow * >(argp1);
33066 {
33067 arg2 = &temp2;
33068 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33069 }
33070 {
33071 PyThreadState* __tstate = wxPyBeginAllowThreads();
33072 (arg1)->SetMaxSize((wxSize const &)*arg2);
33073 wxPyEndAllowThreads(__tstate);
33074 if (PyErr_Occurred()) SWIG_fail;
33075 }
33076 resultobj = SWIG_Py_Void();
33077 return resultobj;
33078 fail:
33079 return NULL;
33080 }
33081
33082
33083 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33084 PyObject *resultobj = 0;
33085 wxWindow *arg1 = (wxWindow *) 0 ;
33086 int result;
33087 void *argp1 = 0 ;
33088 int res1 = 0 ;
33089 PyObject *swig_obj[1] ;
33090
33091 if (!args) SWIG_fail;
33092 swig_obj[0] = args;
33093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33094 if (!SWIG_IsOK(res1)) {
33095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33096 }
33097 arg1 = reinterpret_cast< wxWindow * >(argp1);
33098 {
33099 PyThreadState* __tstate = wxPyBeginAllowThreads();
33100 result = (int)((wxWindow const *)arg1)->GetMinWidth();
33101 wxPyEndAllowThreads(__tstate);
33102 if (PyErr_Occurred()) SWIG_fail;
33103 }
33104 resultobj = SWIG_From_int(static_cast< int >(result));
33105 return resultobj;
33106 fail:
33107 return NULL;
33108 }
33109
33110
33111 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33112 PyObject *resultobj = 0;
33113 wxWindow *arg1 = (wxWindow *) 0 ;
33114 int result;
33115 void *argp1 = 0 ;
33116 int res1 = 0 ;
33117 PyObject *swig_obj[1] ;
33118
33119 if (!args) SWIG_fail;
33120 swig_obj[0] = args;
33121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33122 if (!SWIG_IsOK(res1)) {
33123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33124 }
33125 arg1 = reinterpret_cast< wxWindow * >(argp1);
33126 {
33127 PyThreadState* __tstate = wxPyBeginAllowThreads();
33128 result = (int)((wxWindow const *)arg1)->GetMinHeight();
33129 wxPyEndAllowThreads(__tstate);
33130 if (PyErr_Occurred()) SWIG_fail;
33131 }
33132 resultobj = SWIG_From_int(static_cast< int >(result));
33133 return resultobj;
33134 fail:
33135 return NULL;
33136 }
33137
33138
33139 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33140 PyObject *resultobj = 0;
33141 wxWindow *arg1 = (wxWindow *) 0 ;
33142 int result;
33143 void *argp1 = 0 ;
33144 int res1 = 0 ;
33145 PyObject *swig_obj[1] ;
33146
33147 if (!args) SWIG_fail;
33148 swig_obj[0] = args;
33149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33150 if (!SWIG_IsOK(res1)) {
33151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33152 }
33153 arg1 = reinterpret_cast< wxWindow * >(argp1);
33154 {
33155 PyThreadState* __tstate = wxPyBeginAllowThreads();
33156 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
33157 wxPyEndAllowThreads(__tstate);
33158 if (PyErr_Occurred()) SWIG_fail;
33159 }
33160 resultobj = SWIG_From_int(static_cast< int >(result));
33161 return resultobj;
33162 fail:
33163 return NULL;
33164 }
33165
33166
33167 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33168 PyObject *resultobj = 0;
33169 wxWindow *arg1 = (wxWindow *) 0 ;
33170 int result;
33171 void *argp1 = 0 ;
33172 int res1 = 0 ;
33173 PyObject *swig_obj[1] ;
33174
33175 if (!args) SWIG_fail;
33176 swig_obj[0] = args;
33177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33178 if (!SWIG_IsOK(res1)) {
33179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33180 }
33181 arg1 = reinterpret_cast< wxWindow * >(argp1);
33182 {
33183 PyThreadState* __tstate = wxPyBeginAllowThreads();
33184 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
33185 wxPyEndAllowThreads(__tstate);
33186 if (PyErr_Occurred()) SWIG_fail;
33187 }
33188 resultobj = SWIG_From_int(static_cast< int >(result));
33189 return resultobj;
33190 fail:
33191 return NULL;
33192 }
33193
33194
33195 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33196 PyObject *resultobj = 0;
33197 wxWindow *arg1 = (wxWindow *) 0 ;
33198 wxSize *arg2 = 0 ;
33199 void *argp1 = 0 ;
33200 int res1 = 0 ;
33201 wxSize temp2 ;
33202 PyObject * obj0 = 0 ;
33203 PyObject * obj1 = 0 ;
33204 char * kwnames[] = {
33205 (char *) "self",(char *) "size", NULL
33206 };
33207
33208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
33209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33210 if (!SWIG_IsOK(res1)) {
33211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33212 }
33213 arg1 = reinterpret_cast< wxWindow * >(argp1);
33214 {
33215 arg2 = &temp2;
33216 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33217 }
33218 {
33219 PyThreadState* __tstate = wxPyBeginAllowThreads();
33220 (arg1)->SetVirtualSize((wxSize const &)*arg2);
33221 wxPyEndAllowThreads(__tstate);
33222 if (PyErr_Occurred()) SWIG_fail;
33223 }
33224 resultobj = SWIG_Py_Void();
33225 return resultobj;
33226 fail:
33227 return NULL;
33228 }
33229
33230
33231 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33232 PyObject *resultobj = 0;
33233 wxWindow *arg1 = (wxWindow *) 0 ;
33234 int arg2 ;
33235 int arg3 ;
33236 void *argp1 = 0 ;
33237 int res1 = 0 ;
33238 int val2 ;
33239 int ecode2 = 0 ;
33240 int val3 ;
33241 int ecode3 = 0 ;
33242 PyObject * obj0 = 0 ;
33243 PyObject * obj1 = 0 ;
33244 PyObject * obj2 = 0 ;
33245 char * kwnames[] = {
33246 (char *) "self",(char *) "w",(char *) "h", NULL
33247 };
33248
33249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33251 if (!SWIG_IsOK(res1)) {
33252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33253 }
33254 arg1 = reinterpret_cast< wxWindow * >(argp1);
33255 ecode2 = SWIG_AsVal_int(obj1, &val2);
33256 if (!SWIG_IsOK(ecode2)) {
33257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
33258 }
33259 arg2 = static_cast< int >(val2);
33260 ecode3 = SWIG_AsVal_int(obj2, &val3);
33261 if (!SWIG_IsOK(ecode3)) {
33262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
33263 }
33264 arg3 = static_cast< int >(val3);
33265 {
33266 PyThreadState* __tstate = wxPyBeginAllowThreads();
33267 (arg1)->SetVirtualSize(arg2,arg3);
33268 wxPyEndAllowThreads(__tstate);
33269 if (PyErr_Occurred()) SWIG_fail;
33270 }
33271 resultobj = SWIG_Py_Void();
33272 return resultobj;
33273 fail:
33274 return NULL;
33275 }
33276
33277
33278 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33279 PyObject *resultobj = 0;
33280 wxWindow *arg1 = (wxWindow *) 0 ;
33281 wxSize result;
33282 void *argp1 = 0 ;
33283 int res1 = 0 ;
33284 PyObject *swig_obj[1] ;
33285
33286 if (!args) SWIG_fail;
33287 swig_obj[0] = args;
33288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33289 if (!SWIG_IsOK(res1)) {
33290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33291 }
33292 arg1 = reinterpret_cast< wxWindow * >(argp1);
33293 {
33294 PyThreadState* __tstate = wxPyBeginAllowThreads();
33295 result = ((wxWindow const *)arg1)->GetVirtualSize();
33296 wxPyEndAllowThreads(__tstate);
33297 if (PyErr_Occurred()) SWIG_fail;
33298 }
33299 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33300 return resultobj;
33301 fail:
33302 return NULL;
33303 }
33304
33305
33306 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33307 PyObject *resultobj = 0;
33308 wxWindow *arg1 = (wxWindow *) 0 ;
33309 int *arg2 = (int *) 0 ;
33310 int *arg3 = (int *) 0 ;
33311 void *argp1 = 0 ;
33312 int res1 = 0 ;
33313 int temp2 ;
33314 int res2 = SWIG_TMPOBJ ;
33315 int temp3 ;
33316 int res3 = SWIG_TMPOBJ ;
33317 PyObject *swig_obj[1] ;
33318
33319 arg2 = &temp2;
33320 arg3 = &temp3;
33321 if (!args) SWIG_fail;
33322 swig_obj[0] = args;
33323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33324 if (!SWIG_IsOK(res1)) {
33325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
33326 }
33327 arg1 = reinterpret_cast< wxWindow * >(argp1);
33328 {
33329 PyThreadState* __tstate = wxPyBeginAllowThreads();
33330 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
33331 wxPyEndAllowThreads(__tstate);
33332 if (PyErr_Occurred()) SWIG_fail;
33333 }
33334 resultobj = SWIG_Py_Void();
33335 if (SWIG_IsTmpObj(res2)) {
33336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
33337 } else {
33338 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
33340 }
33341 if (SWIG_IsTmpObj(res3)) {
33342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
33343 } else {
33344 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33345 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
33346 }
33347 return resultobj;
33348 fail:
33349 return NULL;
33350 }
33351
33352
33353 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33354 PyObject *resultobj = 0;
33355 wxWindow *arg1 = (wxWindow *) 0 ;
33356 wxSize result;
33357 void *argp1 = 0 ;
33358 int res1 = 0 ;
33359 PyObject *swig_obj[1] ;
33360
33361 if (!args) SWIG_fail;
33362 swig_obj[0] = args;
33363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33364 if (!SWIG_IsOK(res1)) {
33365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33366 }
33367 arg1 = reinterpret_cast< wxWindow * >(argp1);
33368 {
33369 PyThreadState* __tstate = wxPyBeginAllowThreads();
33370 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
33371 wxPyEndAllowThreads(__tstate);
33372 if (PyErr_Occurred()) SWIG_fail;
33373 }
33374 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33375 return resultobj;
33376 fail:
33377 return NULL;
33378 }
33379
33380
33381 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33382 PyObject *resultobj = 0;
33383 wxWindow *arg1 = (wxWindow *) 0 ;
33384 bool arg2 = (bool) true ;
33385 bool result;
33386 void *argp1 = 0 ;
33387 int res1 = 0 ;
33388 bool val2 ;
33389 int ecode2 = 0 ;
33390 PyObject * obj0 = 0 ;
33391 PyObject * obj1 = 0 ;
33392 char * kwnames[] = {
33393 (char *) "self",(char *) "show", NULL
33394 };
33395
33396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
33397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33398 if (!SWIG_IsOK(res1)) {
33399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
33400 }
33401 arg1 = reinterpret_cast< wxWindow * >(argp1);
33402 if (obj1) {
33403 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33404 if (!SWIG_IsOK(ecode2)) {
33405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
33406 }
33407 arg2 = static_cast< bool >(val2);
33408 }
33409 {
33410 PyThreadState* __tstate = wxPyBeginAllowThreads();
33411 result = (bool)(arg1)->Show(arg2);
33412 wxPyEndAllowThreads(__tstate);
33413 if (PyErr_Occurred()) SWIG_fail;
33414 }
33415 {
33416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33417 }
33418 return resultobj;
33419 fail:
33420 return NULL;
33421 }
33422
33423
33424 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33425 PyObject *resultobj = 0;
33426 wxWindow *arg1 = (wxWindow *) 0 ;
33427 bool result;
33428 void *argp1 = 0 ;
33429 int res1 = 0 ;
33430 PyObject *swig_obj[1] ;
33431
33432 if (!args) SWIG_fail;
33433 swig_obj[0] = args;
33434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33435 if (!SWIG_IsOK(res1)) {
33436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
33437 }
33438 arg1 = reinterpret_cast< wxWindow * >(argp1);
33439 {
33440 PyThreadState* __tstate = wxPyBeginAllowThreads();
33441 result = (bool)(arg1)->Hide();
33442 wxPyEndAllowThreads(__tstate);
33443 if (PyErr_Occurred()) SWIG_fail;
33444 }
33445 {
33446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33447 }
33448 return resultobj;
33449 fail:
33450 return NULL;
33451 }
33452
33453
33454 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33455 PyObject *resultobj = 0;
33456 wxWindow *arg1 = (wxWindow *) 0 ;
33457 bool arg2 = (bool) true ;
33458 bool result;
33459 void *argp1 = 0 ;
33460 int res1 = 0 ;
33461 bool val2 ;
33462 int ecode2 = 0 ;
33463 PyObject * obj0 = 0 ;
33464 PyObject * obj1 = 0 ;
33465 char * kwnames[] = {
33466 (char *) "self",(char *) "enable", NULL
33467 };
33468
33469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
33470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33471 if (!SWIG_IsOK(res1)) {
33472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
33473 }
33474 arg1 = reinterpret_cast< wxWindow * >(argp1);
33475 if (obj1) {
33476 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33477 if (!SWIG_IsOK(ecode2)) {
33478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
33479 }
33480 arg2 = static_cast< bool >(val2);
33481 }
33482 {
33483 PyThreadState* __tstate = wxPyBeginAllowThreads();
33484 result = (bool)(arg1)->Enable(arg2);
33485 wxPyEndAllowThreads(__tstate);
33486 if (PyErr_Occurred()) SWIG_fail;
33487 }
33488 {
33489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33490 }
33491 return resultobj;
33492 fail:
33493 return NULL;
33494 }
33495
33496
33497 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33498 PyObject *resultobj = 0;
33499 wxWindow *arg1 = (wxWindow *) 0 ;
33500 bool result;
33501 void *argp1 = 0 ;
33502 int res1 = 0 ;
33503 PyObject *swig_obj[1] ;
33504
33505 if (!args) SWIG_fail;
33506 swig_obj[0] = args;
33507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33508 if (!SWIG_IsOK(res1)) {
33509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
33510 }
33511 arg1 = reinterpret_cast< wxWindow * >(argp1);
33512 {
33513 PyThreadState* __tstate = wxPyBeginAllowThreads();
33514 result = (bool)(arg1)->Disable();
33515 wxPyEndAllowThreads(__tstate);
33516 if (PyErr_Occurred()) SWIG_fail;
33517 }
33518 {
33519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33520 }
33521 return resultobj;
33522 fail:
33523 return NULL;
33524 }
33525
33526
33527 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33528 PyObject *resultobj = 0;
33529 wxWindow *arg1 = (wxWindow *) 0 ;
33530 bool result;
33531 void *argp1 = 0 ;
33532 int res1 = 0 ;
33533 PyObject *swig_obj[1] ;
33534
33535 if (!args) SWIG_fail;
33536 swig_obj[0] = args;
33537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33538 if (!SWIG_IsOK(res1)) {
33539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
33540 }
33541 arg1 = reinterpret_cast< wxWindow * >(argp1);
33542 {
33543 PyThreadState* __tstate = wxPyBeginAllowThreads();
33544 result = (bool)((wxWindow const *)arg1)->IsShown();
33545 wxPyEndAllowThreads(__tstate);
33546 if (PyErr_Occurred()) SWIG_fail;
33547 }
33548 {
33549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33550 }
33551 return resultobj;
33552 fail:
33553 return NULL;
33554 }
33555
33556
33557 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33558 PyObject *resultobj = 0;
33559 wxWindow *arg1 = (wxWindow *) 0 ;
33560 bool result;
33561 void *argp1 = 0 ;
33562 int res1 = 0 ;
33563 PyObject *swig_obj[1] ;
33564
33565 if (!args) SWIG_fail;
33566 swig_obj[0] = args;
33567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33568 if (!SWIG_IsOK(res1)) {
33569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33570 }
33571 arg1 = reinterpret_cast< wxWindow * >(argp1);
33572 {
33573 PyThreadState* __tstate = wxPyBeginAllowThreads();
33574 result = (bool)((wxWindow const *)arg1)->IsEnabled();
33575 wxPyEndAllowThreads(__tstate);
33576 if (PyErr_Occurred()) SWIG_fail;
33577 }
33578 {
33579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33580 }
33581 return resultobj;
33582 fail:
33583 return NULL;
33584 }
33585
33586
33587 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33588 PyObject *resultobj = 0;
33589 wxWindow *arg1 = (wxWindow *) 0 ;
33590 bool result;
33591 void *argp1 = 0 ;
33592 int res1 = 0 ;
33593 PyObject *swig_obj[1] ;
33594
33595 if (!args) SWIG_fail;
33596 swig_obj[0] = args;
33597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33598 if (!SWIG_IsOK(res1)) {
33599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33600 }
33601 arg1 = reinterpret_cast< wxWindow * >(argp1);
33602 {
33603 PyThreadState* __tstate = wxPyBeginAllowThreads();
33604 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33605 wxPyEndAllowThreads(__tstate);
33606 if (PyErr_Occurred()) SWIG_fail;
33607 }
33608 {
33609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33610 }
33611 return resultobj;
33612 fail:
33613 return NULL;
33614 }
33615
33616
33617 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33618 PyObject *resultobj = 0;
33619 wxWindow *arg1 = (wxWindow *) 0 ;
33620 long arg2 ;
33621 void *argp1 = 0 ;
33622 int res1 = 0 ;
33623 long val2 ;
33624 int ecode2 = 0 ;
33625 PyObject * obj0 = 0 ;
33626 PyObject * obj1 = 0 ;
33627 char * kwnames[] = {
33628 (char *) "self",(char *) "style", NULL
33629 };
33630
33631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33633 if (!SWIG_IsOK(res1)) {
33634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33635 }
33636 arg1 = reinterpret_cast< wxWindow * >(argp1);
33637 ecode2 = SWIG_AsVal_long(obj1, &val2);
33638 if (!SWIG_IsOK(ecode2)) {
33639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33640 }
33641 arg2 = static_cast< long >(val2);
33642 {
33643 PyThreadState* __tstate = wxPyBeginAllowThreads();
33644 (arg1)->SetWindowStyleFlag(arg2);
33645 wxPyEndAllowThreads(__tstate);
33646 if (PyErr_Occurred()) SWIG_fail;
33647 }
33648 resultobj = SWIG_Py_Void();
33649 return resultobj;
33650 fail:
33651 return NULL;
33652 }
33653
33654
33655 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33656 PyObject *resultobj = 0;
33657 wxWindow *arg1 = (wxWindow *) 0 ;
33658 long result;
33659 void *argp1 = 0 ;
33660 int res1 = 0 ;
33661 PyObject *swig_obj[1] ;
33662
33663 if (!args) SWIG_fail;
33664 swig_obj[0] = args;
33665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33666 if (!SWIG_IsOK(res1)) {
33667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33668 }
33669 arg1 = reinterpret_cast< wxWindow * >(argp1);
33670 {
33671 PyThreadState* __tstate = wxPyBeginAllowThreads();
33672 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33673 wxPyEndAllowThreads(__tstate);
33674 if (PyErr_Occurred()) SWIG_fail;
33675 }
33676 resultobj = SWIG_From_long(static_cast< long >(result));
33677 return resultobj;
33678 fail:
33679 return NULL;
33680 }
33681
33682
33683 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33684 PyObject *resultobj = 0;
33685 wxWindow *arg1 = (wxWindow *) 0 ;
33686 int arg2 ;
33687 bool result;
33688 void *argp1 = 0 ;
33689 int res1 = 0 ;
33690 int val2 ;
33691 int ecode2 = 0 ;
33692 PyObject * obj0 = 0 ;
33693 PyObject * obj1 = 0 ;
33694 char * kwnames[] = {
33695 (char *) "self",(char *) "flag", NULL
33696 };
33697
33698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33700 if (!SWIG_IsOK(res1)) {
33701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33702 }
33703 arg1 = reinterpret_cast< wxWindow * >(argp1);
33704 ecode2 = SWIG_AsVal_int(obj1, &val2);
33705 if (!SWIG_IsOK(ecode2)) {
33706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33707 }
33708 arg2 = static_cast< int >(val2);
33709 {
33710 PyThreadState* __tstate = wxPyBeginAllowThreads();
33711 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33712 wxPyEndAllowThreads(__tstate);
33713 if (PyErr_Occurred()) SWIG_fail;
33714 }
33715 {
33716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33717 }
33718 return resultobj;
33719 fail:
33720 return NULL;
33721 }
33722
33723
33724 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33725 PyObject *resultobj = 0;
33726 wxWindow *arg1 = (wxWindow *) 0 ;
33727 bool result;
33728 void *argp1 = 0 ;
33729 int res1 = 0 ;
33730 PyObject *swig_obj[1] ;
33731
33732 if (!args) SWIG_fail;
33733 swig_obj[0] = args;
33734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33735 if (!SWIG_IsOK(res1)) {
33736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33737 }
33738 arg1 = reinterpret_cast< wxWindow * >(argp1);
33739 {
33740 PyThreadState* __tstate = wxPyBeginAllowThreads();
33741 result = (bool)((wxWindow const *)arg1)->IsRetained();
33742 wxPyEndAllowThreads(__tstate);
33743 if (PyErr_Occurred()) SWIG_fail;
33744 }
33745 {
33746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33747 }
33748 return resultobj;
33749 fail:
33750 return NULL;
33751 }
33752
33753
33754 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33755 PyObject *resultobj = 0;
33756 wxWindow *arg1 = (wxWindow *) 0 ;
33757 long arg2 ;
33758 void *argp1 = 0 ;
33759 int res1 = 0 ;
33760 long val2 ;
33761 int ecode2 = 0 ;
33762 PyObject * obj0 = 0 ;
33763 PyObject * obj1 = 0 ;
33764 char * kwnames[] = {
33765 (char *) "self",(char *) "exStyle", NULL
33766 };
33767
33768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33770 if (!SWIG_IsOK(res1)) {
33771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33772 }
33773 arg1 = reinterpret_cast< wxWindow * >(argp1);
33774 ecode2 = SWIG_AsVal_long(obj1, &val2);
33775 if (!SWIG_IsOK(ecode2)) {
33776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33777 }
33778 arg2 = static_cast< long >(val2);
33779 {
33780 PyThreadState* __tstate = wxPyBeginAllowThreads();
33781 (arg1)->SetExtraStyle(arg2);
33782 wxPyEndAllowThreads(__tstate);
33783 if (PyErr_Occurred()) SWIG_fail;
33784 }
33785 resultobj = SWIG_Py_Void();
33786 return resultobj;
33787 fail:
33788 return NULL;
33789 }
33790
33791
33792 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33793 PyObject *resultobj = 0;
33794 wxWindow *arg1 = (wxWindow *) 0 ;
33795 long result;
33796 void *argp1 = 0 ;
33797 int res1 = 0 ;
33798 PyObject *swig_obj[1] ;
33799
33800 if (!args) SWIG_fail;
33801 swig_obj[0] = args;
33802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33803 if (!SWIG_IsOK(res1)) {
33804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33805 }
33806 arg1 = reinterpret_cast< wxWindow * >(argp1);
33807 {
33808 PyThreadState* __tstate = wxPyBeginAllowThreads();
33809 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33810 wxPyEndAllowThreads(__tstate);
33811 if (PyErr_Occurred()) SWIG_fail;
33812 }
33813 resultobj = SWIG_From_long(static_cast< long >(result));
33814 return resultobj;
33815 fail:
33816 return NULL;
33817 }
33818
33819
33820 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33821 PyObject *resultobj = 0;
33822 wxWindow *arg1 = (wxWindow *) 0 ;
33823 bool arg2 = (bool) true ;
33824 void *argp1 = 0 ;
33825 int res1 = 0 ;
33826 bool val2 ;
33827 int ecode2 = 0 ;
33828 PyObject * obj0 = 0 ;
33829 PyObject * obj1 = 0 ;
33830 char * kwnames[] = {
33831 (char *) "self",(char *) "modal", NULL
33832 };
33833
33834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33836 if (!SWIG_IsOK(res1)) {
33837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33838 }
33839 arg1 = reinterpret_cast< wxWindow * >(argp1);
33840 if (obj1) {
33841 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33842 if (!SWIG_IsOK(ecode2)) {
33843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33844 }
33845 arg2 = static_cast< bool >(val2);
33846 }
33847 {
33848 PyThreadState* __tstate = wxPyBeginAllowThreads();
33849 (arg1)->MakeModal(arg2);
33850 wxPyEndAllowThreads(__tstate);
33851 if (PyErr_Occurred()) SWIG_fail;
33852 }
33853 resultobj = SWIG_Py_Void();
33854 return resultobj;
33855 fail:
33856 return NULL;
33857 }
33858
33859
33860 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33861 PyObject *resultobj = 0;
33862 wxWindow *arg1 = (wxWindow *) 0 ;
33863 bool arg2 ;
33864 void *argp1 = 0 ;
33865 int res1 = 0 ;
33866 bool val2 ;
33867 int ecode2 = 0 ;
33868 PyObject * obj0 = 0 ;
33869 PyObject * obj1 = 0 ;
33870 char * kwnames[] = {
33871 (char *) "self",(char *) "enableTheme", NULL
33872 };
33873
33874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33876 if (!SWIG_IsOK(res1)) {
33877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33878 }
33879 arg1 = reinterpret_cast< wxWindow * >(argp1);
33880 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33881 if (!SWIG_IsOK(ecode2)) {
33882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33883 }
33884 arg2 = static_cast< bool >(val2);
33885 {
33886 PyThreadState* __tstate = wxPyBeginAllowThreads();
33887 (arg1)->SetThemeEnabled(arg2);
33888 wxPyEndAllowThreads(__tstate);
33889 if (PyErr_Occurred()) SWIG_fail;
33890 }
33891 resultobj = SWIG_Py_Void();
33892 return resultobj;
33893 fail:
33894 return NULL;
33895 }
33896
33897
33898 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33899 PyObject *resultobj = 0;
33900 wxWindow *arg1 = (wxWindow *) 0 ;
33901 bool result;
33902 void *argp1 = 0 ;
33903 int res1 = 0 ;
33904 PyObject *swig_obj[1] ;
33905
33906 if (!args) SWIG_fail;
33907 swig_obj[0] = args;
33908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33909 if (!SWIG_IsOK(res1)) {
33910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33911 }
33912 arg1 = reinterpret_cast< wxWindow * >(argp1);
33913 {
33914 PyThreadState* __tstate = wxPyBeginAllowThreads();
33915 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33916 wxPyEndAllowThreads(__tstate);
33917 if (PyErr_Occurred()) SWIG_fail;
33918 }
33919 {
33920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33921 }
33922 return resultobj;
33923 fail:
33924 return NULL;
33925 }
33926
33927
33928 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33929 PyObject *resultobj = 0;
33930 wxWindow *arg1 = (wxWindow *) 0 ;
33931 void *argp1 = 0 ;
33932 int res1 = 0 ;
33933 PyObject *swig_obj[1] ;
33934
33935 if (!args) SWIG_fail;
33936 swig_obj[0] = args;
33937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33938 if (!SWIG_IsOK(res1)) {
33939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33940 }
33941 arg1 = reinterpret_cast< wxWindow * >(argp1);
33942 {
33943 PyThreadState* __tstate = wxPyBeginAllowThreads();
33944 (arg1)->SetFocus();
33945 wxPyEndAllowThreads(__tstate);
33946 if (PyErr_Occurred()) SWIG_fail;
33947 }
33948 resultobj = SWIG_Py_Void();
33949 return resultobj;
33950 fail:
33951 return NULL;
33952 }
33953
33954
33955 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33956 PyObject *resultobj = 0;
33957 wxWindow *arg1 = (wxWindow *) 0 ;
33958 void *argp1 = 0 ;
33959 int res1 = 0 ;
33960 PyObject *swig_obj[1] ;
33961
33962 if (!args) SWIG_fail;
33963 swig_obj[0] = args;
33964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33965 if (!SWIG_IsOK(res1)) {
33966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33967 }
33968 arg1 = reinterpret_cast< wxWindow * >(argp1);
33969 {
33970 PyThreadState* __tstate = wxPyBeginAllowThreads();
33971 (arg1)->SetFocusFromKbd();
33972 wxPyEndAllowThreads(__tstate);
33973 if (PyErr_Occurred()) SWIG_fail;
33974 }
33975 resultobj = SWIG_Py_Void();
33976 return resultobj;
33977 fail:
33978 return NULL;
33979 }
33980
33981
33982 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33983 PyObject *resultobj = 0;
33984 wxWindow *result = 0 ;
33985
33986 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33987 {
33988 if (!wxPyCheckForApp()) SWIG_fail;
33989 PyThreadState* __tstate = wxPyBeginAllowThreads();
33990 result = (wxWindow *)wxWindow::FindFocus();
33991 wxPyEndAllowThreads(__tstate);
33992 if (PyErr_Occurred()) SWIG_fail;
33993 }
33994 {
33995 resultobj = wxPyMake_wxObject(result, 0);
33996 }
33997 return resultobj;
33998 fail:
33999 return NULL;
34000 }
34001
34002
34003 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34004 PyObject *resultobj = 0;
34005 wxWindow *arg1 = (wxWindow *) 0 ;
34006 bool result;
34007 void *argp1 = 0 ;
34008 int res1 = 0 ;
34009 PyObject *swig_obj[1] ;
34010
34011 if (!args) SWIG_fail;
34012 swig_obj[0] = args;
34013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34014 if (!SWIG_IsOK(res1)) {
34015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
34016 }
34017 arg1 = reinterpret_cast< wxWindow * >(argp1);
34018 {
34019 PyThreadState* __tstate = wxPyBeginAllowThreads();
34020 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
34021 wxPyEndAllowThreads(__tstate);
34022 if (PyErr_Occurred()) SWIG_fail;
34023 }
34024 {
34025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34026 }
34027 return resultobj;
34028 fail:
34029 return NULL;
34030 }
34031
34032
34033 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34034 PyObject *resultobj = 0;
34035 wxWindow *arg1 = (wxWindow *) 0 ;
34036 bool result;
34037 void *argp1 = 0 ;
34038 int res1 = 0 ;
34039 PyObject *swig_obj[1] ;
34040
34041 if (!args) SWIG_fail;
34042 swig_obj[0] = args;
34043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34044 if (!SWIG_IsOK(res1)) {
34045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
34046 }
34047 arg1 = reinterpret_cast< wxWindow * >(argp1);
34048 {
34049 PyThreadState* __tstate = wxPyBeginAllowThreads();
34050 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
34051 wxPyEndAllowThreads(__tstate);
34052 if (PyErr_Occurred()) SWIG_fail;
34053 }
34054 {
34055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34056 }
34057 return resultobj;
34058 fail:
34059 return NULL;
34060 }
34061
34062
34063 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34064 PyObject *resultobj = 0;
34065 wxWindow *arg1 = (wxWindow *) 0 ;
34066 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
34067 bool result;
34068 void *argp1 = 0 ;
34069 int res1 = 0 ;
34070 int val2 ;
34071 int ecode2 = 0 ;
34072 PyObject * obj0 = 0 ;
34073 PyObject * obj1 = 0 ;
34074 char * kwnames[] = {
34075 (char *) "self",(char *) "flags", NULL
34076 };
34077
34078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
34079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34080 if (!SWIG_IsOK(res1)) {
34081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
34082 }
34083 arg1 = reinterpret_cast< wxWindow * >(argp1);
34084 if (obj1) {
34085 ecode2 = SWIG_AsVal_int(obj1, &val2);
34086 if (!SWIG_IsOK(ecode2)) {
34087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
34088 }
34089 arg2 = static_cast< int >(val2);
34090 }
34091 {
34092 PyThreadState* __tstate = wxPyBeginAllowThreads();
34093 result = (bool)(arg1)->Navigate(arg2);
34094 wxPyEndAllowThreads(__tstate);
34095 if (PyErr_Occurred()) SWIG_fail;
34096 }
34097 {
34098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34099 }
34100 return resultobj;
34101 fail:
34102 return NULL;
34103 }
34104
34105
34106 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34107 PyObject *resultobj = 0;
34108 wxWindow *arg1 = (wxWindow *) 0 ;
34109 wxWindow *arg2 = (wxWindow *) 0 ;
34110 void *argp1 = 0 ;
34111 int res1 = 0 ;
34112 void *argp2 = 0 ;
34113 int res2 = 0 ;
34114 PyObject * obj0 = 0 ;
34115 PyObject * obj1 = 0 ;
34116 char * kwnames[] = {
34117 (char *) "self",(char *) "win", NULL
34118 };
34119
34120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34122 if (!SWIG_IsOK(res1)) {
34123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34124 }
34125 arg1 = reinterpret_cast< wxWindow * >(argp1);
34126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34127 if (!SWIG_IsOK(res2)) {
34128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34129 }
34130 arg2 = reinterpret_cast< wxWindow * >(argp2);
34131 {
34132 PyThreadState* __tstate = wxPyBeginAllowThreads();
34133 (arg1)->MoveAfterInTabOrder(arg2);
34134 wxPyEndAllowThreads(__tstate);
34135 if (PyErr_Occurred()) SWIG_fail;
34136 }
34137 resultobj = SWIG_Py_Void();
34138 return resultobj;
34139 fail:
34140 return NULL;
34141 }
34142
34143
34144 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34145 PyObject *resultobj = 0;
34146 wxWindow *arg1 = (wxWindow *) 0 ;
34147 wxWindow *arg2 = (wxWindow *) 0 ;
34148 void *argp1 = 0 ;
34149 int res1 = 0 ;
34150 void *argp2 = 0 ;
34151 int res2 = 0 ;
34152 PyObject * obj0 = 0 ;
34153 PyObject * obj1 = 0 ;
34154 char * kwnames[] = {
34155 (char *) "self",(char *) "win", NULL
34156 };
34157
34158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34160 if (!SWIG_IsOK(res1)) {
34161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34162 }
34163 arg1 = reinterpret_cast< wxWindow * >(argp1);
34164 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34165 if (!SWIG_IsOK(res2)) {
34166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34167 }
34168 arg2 = reinterpret_cast< wxWindow * >(argp2);
34169 {
34170 PyThreadState* __tstate = wxPyBeginAllowThreads();
34171 (arg1)->MoveBeforeInTabOrder(arg2);
34172 wxPyEndAllowThreads(__tstate);
34173 if (PyErr_Occurred()) SWIG_fail;
34174 }
34175 resultobj = SWIG_Py_Void();
34176 return resultobj;
34177 fail:
34178 return NULL;
34179 }
34180
34181
34182 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34183 PyObject *resultobj = 0;
34184 wxWindow *arg1 = (wxWindow *) 0 ;
34185 PyObject *result = 0 ;
34186 void *argp1 = 0 ;
34187 int res1 = 0 ;
34188 PyObject *swig_obj[1] ;
34189
34190 if (!args) SWIG_fail;
34191 swig_obj[0] = args;
34192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34193 if (!SWIG_IsOK(res1)) {
34194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
34195 }
34196 arg1 = reinterpret_cast< wxWindow * >(argp1);
34197 {
34198 PyThreadState* __tstate = wxPyBeginAllowThreads();
34199 result = (PyObject *)wxWindow_GetChildren(arg1);
34200 wxPyEndAllowThreads(__tstate);
34201 if (PyErr_Occurred()) SWIG_fail;
34202 }
34203 resultobj = result;
34204 return resultobj;
34205 fail:
34206 return NULL;
34207 }
34208
34209
34210 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34211 PyObject *resultobj = 0;
34212 wxWindow *arg1 = (wxWindow *) 0 ;
34213 wxWindow *result = 0 ;
34214 void *argp1 = 0 ;
34215 int res1 = 0 ;
34216 PyObject *swig_obj[1] ;
34217
34218 if (!args) SWIG_fail;
34219 swig_obj[0] = args;
34220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34221 if (!SWIG_IsOK(res1)) {
34222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34223 }
34224 arg1 = reinterpret_cast< wxWindow * >(argp1);
34225 {
34226 PyThreadState* __tstate = wxPyBeginAllowThreads();
34227 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
34228 wxPyEndAllowThreads(__tstate);
34229 if (PyErr_Occurred()) SWIG_fail;
34230 }
34231 {
34232 resultobj = wxPyMake_wxObject(result, 0);
34233 }
34234 return resultobj;
34235 fail:
34236 return NULL;
34237 }
34238
34239
34240 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34241 PyObject *resultobj = 0;
34242 wxWindow *arg1 = (wxWindow *) 0 ;
34243 wxWindow *result = 0 ;
34244 void *argp1 = 0 ;
34245 int res1 = 0 ;
34246 PyObject *swig_obj[1] ;
34247
34248 if (!args) SWIG_fail;
34249 swig_obj[0] = args;
34250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34251 if (!SWIG_IsOK(res1)) {
34252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34253 }
34254 arg1 = reinterpret_cast< wxWindow * >(argp1);
34255 {
34256 PyThreadState* __tstate = wxPyBeginAllowThreads();
34257 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
34258 wxPyEndAllowThreads(__tstate);
34259 if (PyErr_Occurred()) SWIG_fail;
34260 }
34261 {
34262 resultobj = wxPyMake_wxObject(result, 0);
34263 }
34264 return resultobj;
34265 fail:
34266 return NULL;
34267 }
34268
34269
34270 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34271 PyObject *resultobj = 0;
34272 wxWindow *arg1 = (wxWindow *) 0 ;
34273 bool result;
34274 void *argp1 = 0 ;
34275 int res1 = 0 ;
34276 PyObject *swig_obj[1] ;
34277
34278 if (!args) SWIG_fail;
34279 swig_obj[0] = args;
34280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34281 if (!SWIG_IsOK(res1)) {
34282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
34283 }
34284 arg1 = reinterpret_cast< wxWindow * >(argp1);
34285 {
34286 PyThreadState* __tstate = wxPyBeginAllowThreads();
34287 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
34288 wxPyEndAllowThreads(__tstate);
34289 if (PyErr_Occurred()) SWIG_fail;
34290 }
34291 {
34292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34293 }
34294 return resultobj;
34295 fail:
34296 return NULL;
34297 }
34298
34299
34300 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34301 PyObject *resultobj = 0;
34302 wxWindow *arg1 = (wxWindow *) 0 ;
34303 wxWindow *arg2 = (wxWindow *) 0 ;
34304 bool result;
34305 void *argp1 = 0 ;
34306 int res1 = 0 ;
34307 void *argp2 = 0 ;
34308 int res2 = 0 ;
34309 PyObject * obj0 = 0 ;
34310 PyObject * obj1 = 0 ;
34311 char * kwnames[] = {
34312 (char *) "self",(char *) "newParent", NULL
34313 };
34314
34315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
34316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34317 if (!SWIG_IsOK(res1)) {
34318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
34319 }
34320 arg1 = reinterpret_cast< wxWindow * >(argp1);
34321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34322 if (!SWIG_IsOK(res2)) {
34323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
34324 }
34325 arg2 = reinterpret_cast< wxWindow * >(argp2);
34326 {
34327 PyThreadState* __tstate = wxPyBeginAllowThreads();
34328 result = (bool)(arg1)->Reparent(arg2);
34329 wxPyEndAllowThreads(__tstate);
34330 if (PyErr_Occurred()) SWIG_fail;
34331 }
34332 {
34333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34334 }
34335 return resultobj;
34336 fail:
34337 return NULL;
34338 }
34339
34340
34341 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34342 PyObject *resultobj = 0;
34343 wxWindow *arg1 = (wxWindow *) 0 ;
34344 wxWindow *arg2 = (wxWindow *) 0 ;
34345 void *argp1 = 0 ;
34346 int res1 = 0 ;
34347 void *argp2 = 0 ;
34348 int res2 = 0 ;
34349 PyObject * obj0 = 0 ;
34350 PyObject * obj1 = 0 ;
34351 char * kwnames[] = {
34352 (char *) "self",(char *) "child", NULL
34353 };
34354
34355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
34356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34357 if (!SWIG_IsOK(res1)) {
34358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34359 }
34360 arg1 = reinterpret_cast< wxWindow * >(argp1);
34361 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34362 if (!SWIG_IsOK(res2)) {
34363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34364 }
34365 arg2 = reinterpret_cast< wxWindow * >(argp2);
34366 {
34367 PyThreadState* __tstate = wxPyBeginAllowThreads();
34368 (arg1)->AddChild(arg2);
34369 wxPyEndAllowThreads(__tstate);
34370 if (PyErr_Occurred()) SWIG_fail;
34371 }
34372 resultobj = SWIG_Py_Void();
34373 return resultobj;
34374 fail:
34375 return NULL;
34376 }
34377
34378
34379 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34380 PyObject *resultobj = 0;
34381 wxWindow *arg1 = (wxWindow *) 0 ;
34382 wxWindow *arg2 = (wxWindow *) 0 ;
34383 void *argp1 = 0 ;
34384 int res1 = 0 ;
34385 void *argp2 = 0 ;
34386 int res2 = 0 ;
34387 PyObject * obj0 = 0 ;
34388 PyObject * obj1 = 0 ;
34389 char * kwnames[] = {
34390 (char *) "self",(char *) "child", NULL
34391 };
34392
34393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
34394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34395 if (!SWIG_IsOK(res1)) {
34396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34397 }
34398 arg1 = reinterpret_cast< wxWindow * >(argp1);
34399 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34400 if (!SWIG_IsOK(res2)) {
34401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34402 }
34403 arg2 = reinterpret_cast< wxWindow * >(argp2);
34404 {
34405 PyThreadState* __tstate = wxPyBeginAllowThreads();
34406 (arg1)->RemoveChild(arg2);
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_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34418 PyObject *resultobj = 0;
34419 wxWindow *arg1 = (wxWindow *) 0 ;
34420 bool arg2 ;
34421 void *argp1 = 0 ;
34422 int res1 = 0 ;
34423 bool val2 ;
34424 int ecode2 = 0 ;
34425 PyObject * obj0 = 0 ;
34426 PyObject * obj1 = 0 ;
34427 char * kwnames[] = {
34428 (char *) "self",(char *) "on", NULL
34429 };
34430
34431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",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_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
34435 }
34436 arg1 = reinterpret_cast< wxWindow * >(argp1);
34437 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34438 if (!SWIG_IsOK(ecode2)) {
34439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
34440 }
34441 arg2 = static_cast< bool >(val2);
34442 {
34443 PyThreadState* __tstate = wxPyBeginAllowThreads();
34444 wxWindow_SetDoubleBuffered(arg1,arg2);
34445 wxPyEndAllowThreads(__tstate);
34446 if (PyErr_Occurred()) SWIG_fail;
34447 }
34448 resultobj = SWIG_Py_Void();
34449 return resultobj;
34450 fail:
34451 return NULL;
34452 }
34453
34454
34455 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34456 PyObject *resultobj = 0;
34457 wxWindow *arg1 = (wxWindow *) 0 ;
34458 long arg2 ;
34459 wxWindow *result = 0 ;
34460 void *argp1 = 0 ;
34461 int res1 = 0 ;
34462 long val2 ;
34463 int ecode2 = 0 ;
34464 PyObject * obj0 = 0 ;
34465 PyObject * obj1 = 0 ;
34466 char * kwnames[] = {
34467 (char *) "self",(char *) "winid", NULL
34468 };
34469
34470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
34471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34472 if (!SWIG_IsOK(res1)) {
34473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
34474 }
34475 arg1 = reinterpret_cast< wxWindow * >(argp1);
34476 ecode2 = SWIG_AsVal_long(obj1, &val2);
34477 if (!SWIG_IsOK(ecode2)) {
34478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
34479 }
34480 arg2 = static_cast< long >(val2);
34481 {
34482 PyThreadState* __tstate = wxPyBeginAllowThreads();
34483 result = (wxWindow *)(arg1)->FindWindow(arg2);
34484 wxPyEndAllowThreads(__tstate);
34485 if (PyErr_Occurred()) SWIG_fail;
34486 }
34487 {
34488 resultobj = wxPyMake_wxObject(result, 0);
34489 }
34490 return resultobj;
34491 fail:
34492 return NULL;
34493 }
34494
34495
34496 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34497 PyObject *resultobj = 0;
34498 wxWindow *arg1 = (wxWindow *) 0 ;
34499 wxString *arg2 = 0 ;
34500 wxWindow *result = 0 ;
34501 void *argp1 = 0 ;
34502 int res1 = 0 ;
34503 bool temp2 = false ;
34504 PyObject * obj0 = 0 ;
34505 PyObject * obj1 = 0 ;
34506 char * kwnames[] = {
34507 (char *) "self",(char *) "name", NULL
34508 };
34509
34510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
34511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34512 if (!SWIG_IsOK(res1)) {
34513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
34514 }
34515 arg1 = reinterpret_cast< wxWindow * >(argp1);
34516 {
34517 arg2 = wxString_in_helper(obj1);
34518 if (arg2 == NULL) SWIG_fail;
34519 temp2 = true;
34520 }
34521 {
34522 PyThreadState* __tstate = wxPyBeginAllowThreads();
34523 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
34524 wxPyEndAllowThreads(__tstate);
34525 if (PyErr_Occurred()) SWIG_fail;
34526 }
34527 {
34528 resultobj = wxPyMake_wxObject(result, 0);
34529 }
34530 {
34531 if (temp2)
34532 delete arg2;
34533 }
34534 return resultobj;
34535 fail:
34536 {
34537 if (temp2)
34538 delete arg2;
34539 }
34540 return NULL;
34541 }
34542
34543
34544 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34545 PyObject *resultobj = 0;
34546 wxWindow *arg1 = (wxWindow *) 0 ;
34547 wxEvtHandler *result = 0 ;
34548 void *argp1 = 0 ;
34549 int res1 = 0 ;
34550 PyObject *swig_obj[1] ;
34551
34552 if (!args) SWIG_fail;
34553 swig_obj[0] = args;
34554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34555 if (!SWIG_IsOK(res1)) {
34556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
34557 }
34558 arg1 = reinterpret_cast< wxWindow * >(argp1);
34559 {
34560 PyThreadState* __tstate = wxPyBeginAllowThreads();
34561 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
34562 wxPyEndAllowThreads(__tstate);
34563 if (PyErr_Occurred()) SWIG_fail;
34564 }
34565 {
34566 resultobj = wxPyMake_wxObject(result, 0);
34567 }
34568 return resultobj;
34569 fail:
34570 return NULL;
34571 }
34572
34573
34574 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34575 PyObject *resultobj = 0;
34576 wxWindow *arg1 = (wxWindow *) 0 ;
34577 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34578 void *argp1 = 0 ;
34579 int res1 = 0 ;
34580 void *argp2 = 0 ;
34581 int res2 = 0 ;
34582 PyObject * obj0 = 0 ;
34583 PyObject * obj1 = 0 ;
34584 char * kwnames[] = {
34585 (char *) "self",(char *) "handler", NULL
34586 };
34587
34588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34590 if (!SWIG_IsOK(res1)) {
34591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34592 }
34593 arg1 = reinterpret_cast< wxWindow * >(argp1);
34594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34595 if (!SWIG_IsOK(res2)) {
34596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34597 }
34598 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34599 {
34600 PyThreadState* __tstate = wxPyBeginAllowThreads();
34601 (arg1)->SetEventHandler(arg2);
34602 wxPyEndAllowThreads(__tstate);
34603 if (PyErr_Occurred()) SWIG_fail;
34604 }
34605 resultobj = SWIG_Py_Void();
34606 return resultobj;
34607 fail:
34608 return NULL;
34609 }
34610
34611
34612 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34613 PyObject *resultobj = 0;
34614 wxWindow *arg1 = (wxWindow *) 0 ;
34615 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34616 void *argp1 = 0 ;
34617 int res1 = 0 ;
34618 void *argp2 = 0 ;
34619 int res2 = 0 ;
34620 PyObject * obj0 = 0 ;
34621 PyObject * obj1 = 0 ;
34622 char * kwnames[] = {
34623 (char *) "self",(char *) "handler", NULL
34624 };
34625
34626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34628 if (!SWIG_IsOK(res1)) {
34629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34630 }
34631 arg1 = reinterpret_cast< wxWindow * >(argp1);
34632 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34633 if (!SWIG_IsOK(res2)) {
34634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34635 }
34636 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34637 {
34638 PyThreadState* __tstate = wxPyBeginAllowThreads();
34639 (arg1)->PushEventHandler(arg2);
34640 wxPyEndAllowThreads(__tstate);
34641 if (PyErr_Occurred()) SWIG_fail;
34642 }
34643 resultobj = SWIG_Py_Void();
34644 return resultobj;
34645 fail:
34646 return NULL;
34647 }
34648
34649
34650 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34651 PyObject *resultobj = 0;
34652 wxWindow *arg1 = (wxWindow *) 0 ;
34653 bool arg2 = (bool) false ;
34654 wxEvtHandler *result = 0 ;
34655 void *argp1 = 0 ;
34656 int res1 = 0 ;
34657 bool val2 ;
34658 int ecode2 = 0 ;
34659 PyObject * obj0 = 0 ;
34660 PyObject * obj1 = 0 ;
34661 char * kwnames[] = {
34662 (char *) "self",(char *) "deleteHandler", NULL
34663 };
34664
34665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34667 if (!SWIG_IsOK(res1)) {
34668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34669 }
34670 arg1 = reinterpret_cast< wxWindow * >(argp1);
34671 if (obj1) {
34672 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34673 if (!SWIG_IsOK(ecode2)) {
34674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34675 }
34676 arg2 = static_cast< bool >(val2);
34677 }
34678 {
34679 PyThreadState* __tstate = wxPyBeginAllowThreads();
34680 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34681 wxPyEndAllowThreads(__tstate);
34682 if (PyErr_Occurred()) SWIG_fail;
34683 }
34684 {
34685 resultobj = wxPyMake_wxObject(result, 0);
34686 }
34687 return resultobj;
34688 fail:
34689 return NULL;
34690 }
34691
34692
34693 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34694 PyObject *resultobj = 0;
34695 wxWindow *arg1 = (wxWindow *) 0 ;
34696 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34697 bool result;
34698 void *argp1 = 0 ;
34699 int res1 = 0 ;
34700 void *argp2 = 0 ;
34701 int res2 = 0 ;
34702 PyObject * obj0 = 0 ;
34703 PyObject * obj1 = 0 ;
34704 char * kwnames[] = {
34705 (char *) "self",(char *) "handler", NULL
34706 };
34707
34708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34710 if (!SWIG_IsOK(res1)) {
34711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34712 }
34713 arg1 = reinterpret_cast< wxWindow * >(argp1);
34714 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34715 if (!SWIG_IsOK(res2)) {
34716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34717 }
34718 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34719 {
34720 PyThreadState* __tstate = wxPyBeginAllowThreads();
34721 result = (bool)(arg1)->RemoveEventHandler(arg2);
34722 wxPyEndAllowThreads(__tstate);
34723 if (PyErr_Occurred()) SWIG_fail;
34724 }
34725 {
34726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34727 }
34728 return resultobj;
34729 fail:
34730 return NULL;
34731 }
34732
34733
34734 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34735 PyObject *resultobj = 0;
34736 wxWindow *arg1 = (wxWindow *) 0 ;
34737 wxValidator *arg2 = 0 ;
34738 void *argp1 = 0 ;
34739 int res1 = 0 ;
34740 void *argp2 = 0 ;
34741 int res2 = 0 ;
34742 PyObject * obj0 = 0 ;
34743 PyObject * obj1 = 0 ;
34744 char * kwnames[] = {
34745 (char *) "self",(char *) "validator", NULL
34746 };
34747
34748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34750 if (!SWIG_IsOK(res1)) {
34751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34752 }
34753 arg1 = reinterpret_cast< wxWindow * >(argp1);
34754 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34755 if (!SWIG_IsOK(res2)) {
34756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34757 }
34758 if (!argp2) {
34759 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34760 }
34761 arg2 = reinterpret_cast< wxValidator * >(argp2);
34762 {
34763 PyThreadState* __tstate = wxPyBeginAllowThreads();
34764 (arg1)->SetValidator((wxValidator const &)*arg2);
34765 wxPyEndAllowThreads(__tstate);
34766 if (PyErr_Occurred()) SWIG_fail;
34767 }
34768 resultobj = SWIG_Py_Void();
34769 return resultobj;
34770 fail:
34771 return NULL;
34772 }
34773
34774
34775 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34776 PyObject *resultobj = 0;
34777 wxWindow *arg1 = (wxWindow *) 0 ;
34778 wxValidator *result = 0 ;
34779 void *argp1 = 0 ;
34780 int res1 = 0 ;
34781 PyObject *swig_obj[1] ;
34782
34783 if (!args) SWIG_fail;
34784 swig_obj[0] = args;
34785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34786 if (!SWIG_IsOK(res1)) {
34787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34788 }
34789 arg1 = reinterpret_cast< wxWindow * >(argp1);
34790 {
34791 PyThreadState* __tstate = wxPyBeginAllowThreads();
34792 result = (wxValidator *)(arg1)->GetValidator();
34793 wxPyEndAllowThreads(__tstate);
34794 if (PyErr_Occurred()) SWIG_fail;
34795 }
34796 {
34797 resultobj = wxPyMake_wxObject(result, (bool)0);
34798 }
34799 return resultobj;
34800 fail:
34801 return NULL;
34802 }
34803
34804
34805 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34806 PyObject *resultobj = 0;
34807 wxWindow *arg1 = (wxWindow *) 0 ;
34808 bool result;
34809 void *argp1 = 0 ;
34810 int res1 = 0 ;
34811 PyObject *swig_obj[1] ;
34812
34813 if (!args) SWIG_fail;
34814 swig_obj[0] = args;
34815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34816 if (!SWIG_IsOK(res1)) {
34817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34818 }
34819 arg1 = reinterpret_cast< wxWindow * >(argp1);
34820 {
34821 PyThreadState* __tstate = wxPyBeginAllowThreads();
34822 result = (bool)(arg1)->Validate();
34823 wxPyEndAllowThreads(__tstate);
34824 if (PyErr_Occurred()) SWIG_fail;
34825 }
34826 {
34827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34828 }
34829 return resultobj;
34830 fail:
34831 return NULL;
34832 }
34833
34834
34835 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34836 PyObject *resultobj = 0;
34837 wxWindow *arg1 = (wxWindow *) 0 ;
34838 bool result;
34839 void *argp1 = 0 ;
34840 int res1 = 0 ;
34841 PyObject *swig_obj[1] ;
34842
34843 if (!args) SWIG_fail;
34844 swig_obj[0] = args;
34845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34846 if (!SWIG_IsOK(res1)) {
34847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34848 }
34849 arg1 = reinterpret_cast< wxWindow * >(argp1);
34850 {
34851 PyThreadState* __tstate = wxPyBeginAllowThreads();
34852 result = (bool)(arg1)->TransferDataToWindow();
34853 wxPyEndAllowThreads(__tstate);
34854 if (PyErr_Occurred()) SWIG_fail;
34855 }
34856 {
34857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34858 }
34859 return resultobj;
34860 fail:
34861 return NULL;
34862 }
34863
34864
34865 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34866 PyObject *resultobj = 0;
34867 wxWindow *arg1 = (wxWindow *) 0 ;
34868 bool result;
34869 void *argp1 = 0 ;
34870 int res1 = 0 ;
34871 PyObject *swig_obj[1] ;
34872
34873 if (!args) SWIG_fail;
34874 swig_obj[0] = args;
34875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34876 if (!SWIG_IsOK(res1)) {
34877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34878 }
34879 arg1 = reinterpret_cast< wxWindow * >(argp1);
34880 {
34881 PyThreadState* __tstate = wxPyBeginAllowThreads();
34882 result = (bool)(arg1)->TransferDataFromWindow();
34883 wxPyEndAllowThreads(__tstate);
34884 if (PyErr_Occurred()) SWIG_fail;
34885 }
34886 {
34887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34888 }
34889 return resultobj;
34890 fail:
34891 return NULL;
34892 }
34893
34894
34895 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34896 PyObject *resultobj = 0;
34897 wxWindow *arg1 = (wxWindow *) 0 ;
34898 void *argp1 = 0 ;
34899 int res1 = 0 ;
34900 PyObject *swig_obj[1] ;
34901
34902 if (!args) SWIG_fail;
34903 swig_obj[0] = args;
34904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34905 if (!SWIG_IsOK(res1)) {
34906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34907 }
34908 arg1 = reinterpret_cast< wxWindow * >(argp1);
34909 {
34910 PyThreadState* __tstate = wxPyBeginAllowThreads();
34911 (arg1)->InitDialog();
34912 wxPyEndAllowThreads(__tstate);
34913 if (PyErr_Occurred()) SWIG_fail;
34914 }
34915 resultobj = SWIG_Py_Void();
34916 return resultobj;
34917 fail:
34918 return NULL;
34919 }
34920
34921
34922 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34923 PyObject *resultobj = 0;
34924 wxWindow *arg1 = (wxWindow *) 0 ;
34925 wxAcceleratorTable *arg2 = 0 ;
34926 void *argp1 = 0 ;
34927 int res1 = 0 ;
34928 void *argp2 = 0 ;
34929 int res2 = 0 ;
34930 PyObject * obj0 = 0 ;
34931 PyObject * obj1 = 0 ;
34932 char * kwnames[] = {
34933 (char *) "self",(char *) "accel", NULL
34934 };
34935
34936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34938 if (!SWIG_IsOK(res1)) {
34939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34940 }
34941 arg1 = reinterpret_cast< wxWindow * >(argp1);
34942 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34943 if (!SWIG_IsOK(res2)) {
34944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34945 }
34946 if (!argp2) {
34947 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34948 }
34949 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34950 {
34951 PyThreadState* __tstate = wxPyBeginAllowThreads();
34952 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34953 wxPyEndAllowThreads(__tstate);
34954 if (PyErr_Occurred()) SWIG_fail;
34955 }
34956 resultobj = SWIG_Py_Void();
34957 return resultobj;
34958 fail:
34959 return NULL;
34960 }
34961
34962
34963 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34964 PyObject *resultobj = 0;
34965 wxWindow *arg1 = (wxWindow *) 0 ;
34966 wxAcceleratorTable *result = 0 ;
34967 void *argp1 = 0 ;
34968 int res1 = 0 ;
34969 PyObject *swig_obj[1] ;
34970
34971 if (!args) SWIG_fail;
34972 swig_obj[0] = args;
34973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34974 if (!SWIG_IsOK(res1)) {
34975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34976 }
34977 arg1 = reinterpret_cast< wxWindow * >(argp1);
34978 {
34979 PyThreadState* __tstate = wxPyBeginAllowThreads();
34980 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34981 wxPyEndAllowThreads(__tstate);
34982 if (PyErr_Occurred()) SWIG_fail;
34983 }
34984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34985 return resultobj;
34986 fail:
34987 return NULL;
34988 }
34989
34990
34991 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34992 PyObject *resultobj = 0;
34993 wxWindow *arg1 = (wxWindow *) 0 ;
34994 int arg2 ;
34995 int arg3 ;
34996 int arg4 ;
34997 bool result;
34998 void *argp1 = 0 ;
34999 int res1 = 0 ;
35000 int val2 ;
35001 int ecode2 = 0 ;
35002 int val3 ;
35003 int ecode3 = 0 ;
35004 int val4 ;
35005 int ecode4 = 0 ;
35006 PyObject * obj0 = 0 ;
35007 PyObject * obj1 = 0 ;
35008 PyObject * obj2 = 0 ;
35009 PyObject * obj3 = 0 ;
35010 char * kwnames[] = {
35011 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
35012 };
35013
35014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35016 if (!SWIG_IsOK(res1)) {
35017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35018 }
35019 arg1 = reinterpret_cast< wxWindow * >(argp1);
35020 ecode2 = SWIG_AsVal_int(obj1, &val2);
35021 if (!SWIG_IsOK(ecode2)) {
35022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
35023 }
35024 arg2 = static_cast< int >(val2);
35025 ecode3 = SWIG_AsVal_int(obj2, &val3);
35026 if (!SWIG_IsOK(ecode3)) {
35027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
35028 }
35029 arg3 = static_cast< int >(val3);
35030 ecode4 = SWIG_AsVal_int(obj3, &val4);
35031 if (!SWIG_IsOK(ecode4)) {
35032 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
35033 }
35034 arg4 = static_cast< int >(val4);
35035 {
35036 PyThreadState* __tstate = wxPyBeginAllowThreads();
35037 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
35038 wxPyEndAllowThreads(__tstate);
35039 if (PyErr_Occurred()) SWIG_fail;
35040 }
35041 {
35042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35043 }
35044 return resultobj;
35045 fail:
35046 return NULL;
35047 }
35048
35049
35050 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35051 PyObject *resultobj = 0;
35052 wxWindow *arg1 = (wxWindow *) 0 ;
35053 int arg2 ;
35054 bool result;
35055 void *argp1 = 0 ;
35056 int res1 = 0 ;
35057 int val2 ;
35058 int ecode2 = 0 ;
35059 PyObject * obj0 = 0 ;
35060 PyObject * obj1 = 0 ;
35061 char * kwnames[] = {
35062 (char *) "self",(char *) "hotkeyId", NULL
35063 };
35064
35065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
35066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35067 if (!SWIG_IsOK(res1)) {
35068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35069 }
35070 arg1 = reinterpret_cast< wxWindow * >(argp1);
35071 ecode2 = SWIG_AsVal_int(obj1, &val2);
35072 if (!SWIG_IsOK(ecode2)) {
35073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
35074 }
35075 arg2 = static_cast< int >(val2);
35076 {
35077 PyThreadState* __tstate = wxPyBeginAllowThreads();
35078 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
35079 wxPyEndAllowThreads(__tstate);
35080 if (PyErr_Occurred()) SWIG_fail;
35081 }
35082 {
35083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35084 }
35085 return resultobj;
35086 fail:
35087 return NULL;
35088 }
35089
35090
35091 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35092 PyObject *resultobj = 0;
35093 wxWindow *arg1 = (wxWindow *) 0 ;
35094 wxPoint *arg2 = 0 ;
35095 wxPoint result;
35096 void *argp1 = 0 ;
35097 int res1 = 0 ;
35098 wxPoint temp2 ;
35099 PyObject * obj0 = 0 ;
35100 PyObject * obj1 = 0 ;
35101 char * kwnames[] = {
35102 (char *) "self",(char *) "pt", NULL
35103 };
35104
35105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35107 if (!SWIG_IsOK(res1)) {
35108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35109 }
35110 arg1 = reinterpret_cast< wxWindow * >(argp1);
35111 {
35112 arg2 = &temp2;
35113 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35114 }
35115 {
35116 PyThreadState* __tstate = wxPyBeginAllowThreads();
35117 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35118 wxPyEndAllowThreads(__tstate);
35119 if (PyErr_Occurred()) SWIG_fail;
35120 }
35121 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35122 return resultobj;
35123 fail:
35124 return NULL;
35125 }
35126
35127
35128 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35129 PyObject *resultobj = 0;
35130 wxWindow *arg1 = (wxWindow *) 0 ;
35131 wxSize *arg2 = 0 ;
35132 wxSize result;
35133 void *argp1 = 0 ;
35134 int res1 = 0 ;
35135 wxSize temp2 ;
35136 PyObject * obj0 = 0 ;
35137 PyObject * obj1 = 0 ;
35138 char * kwnames[] = {
35139 (char *) "self",(char *) "sz", NULL
35140 };
35141
35142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35144 if (!SWIG_IsOK(res1)) {
35145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35146 }
35147 arg1 = reinterpret_cast< wxWindow * >(argp1);
35148 {
35149 arg2 = &temp2;
35150 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35151 }
35152 {
35153 PyThreadState* __tstate = wxPyBeginAllowThreads();
35154 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35155 wxPyEndAllowThreads(__tstate);
35156 if (PyErr_Occurred()) SWIG_fail;
35157 }
35158 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35159 return resultobj;
35160 fail:
35161 return NULL;
35162 }
35163
35164
35165 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35166 PyObject *resultobj = 0;
35167 wxWindow *arg1 = (wxWindow *) 0 ;
35168 wxPoint *arg2 = 0 ;
35169 wxPoint result;
35170 void *argp1 = 0 ;
35171 int res1 = 0 ;
35172 wxPoint temp2 ;
35173 PyObject * obj0 = 0 ;
35174 PyObject * obj1 = 0 ;
35175 char * kwnames[] = {
35176 (char *) "self",(char *) "pt", NULL
35177 };
35178
35179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
35180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35181 if (!SWIG_IsOK(res1)) {
35182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
35183 }
35184 arg1 = reinterpret_cast< wxWindow * >(argp1);
35185 {
35186 arg2 = &temp2;
35187 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35188 }
35189 {
35190 PyThreadState* __tstate = wxPyBeginAllowThreads();
35191 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35192 wxPyEndAllowThreads(__tstate);
35193 if (PyErr_Occurred()) SWIG_fail;
35194 }
35195 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35196 return resultobj;
35197 fail:
35198 return NULL;
35199 }
35200
35201
35202 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35203 PyObject *resultobj = 0;
35204 wxWindow *arg1 = (wxWindow *) 0 ;
35205 wxSize *arg2 = 0 ;
35206 wxSize result;
35207 void *argp1 = 0 ;
35208 int res1 = 0 ;
35209 wxSize temp2 ;
35210 PyObject * obj0 = 0 ;
35211 PyObject * obj1 = 0 ;
35212 char * kwnames[] = {
35213 (char *) "self",(char *) "sz", NULL
35214 };
35215
35216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
35217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35218 if (!SWIG_IsOK(res1)) {
35219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
35220 }
35221 arg1 = reinterpret_cast< wxWindow * >(argp1);
35222 {
35223 arg2 = &temp2;
35224 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35225 }
35226 {
35227 PyThreadState* __tstate = wxPyBeginAllowThreads();
35228 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35229 wxPyEndAllowThreads(__tstate);
35230 if (PyErr_Occurred()) SWIG_fail;
35231 }
35232 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35233 return resultobj;
35234 fail:
35235 return NULL;
35236 }
35237
35238
35239 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35240 PyObject *resultobj = 0;
35241 wxWindow *arg1 = (wxWindow *) 0 ;
35242 wxPoint *arg2 = 0 ;
35243 wxPoint result;
35244 void *argp1 = 0 ;
35245 int res1 = 0 ;
35246 wxPoint temp2 ;
35247 PyObject * obj0 = 0 ;
35248 PyObject * obj1 = 0 ;
35249 char * kwnames[] = {
35250 (char *) "self",(char *) "pt", NULL
35251 };
35252
35253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35255 if (!SWIG_IsOK(res1)) {
35256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35257 }
35258 arg1 = reinterpret_cast< wxWindow * >(argp1);
35259 {
35260 arg2 = &temp2;
35261 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35262 }
35263 {
35264 PyThreadState* __tstate = wxPyBeginAllowThreads();
35265 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
35266 wxPyEndAllowThreads(__tstate);
35267 if (PyErr_Occurred()) SWIG_fail;
35268 }
35269 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35270 return resultobj;
35271 fail:
35272 return NULL;
35273 }
35274
35275
35276 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35277 PyObject *resultobj = 0;
35278 wxWindow *arg1 = (wxWindow *) 0 ;
35279 wxSize *arg2 = 0 ;
35280 wxSize result;
35281 void *argp1 = 0 ;
35282 int res1 = 0 ;
35283 wxSize temp2 ;
35284 PyObject * obj0 = 0 ;
35285 PyObject * obj1 = 0 ;
35286 char * kwnames[] = {
35287 (char *) "self",(char *) "sz", NULL
35288 };
35289
35290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35292 if (!SWIG_IsOK(res1)) {
35293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35294 }
35295 arg1 = reinterpret_cast< wxWindow * >(argp1);
35296 {
35297 arg2 = &temp2;
35298 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35299 }
35300 {
35301 PyThreadState* __tstate = wxPyBeginAllowThreads();
35302 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
35303 wxPyEndAllowThreads(__tstate);
35304 if (PyErr_Occurred()) SWIG_fail;
35305 }
35306 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35307 return resultobj;
35308 fail:
35309 return NULL;
35310 }
35311
35312
35313 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35314 PyObject *resultobj = 0;
35315 wxWindow *arg1 = (wxWindow *) 0 ;
35316 int arg2 ;
35317 int arg3 ;
35318 void *argp1 = 0 ;
35319 int res1 = 0 ;
35320 int val2 ;
35321 int ecode2 = 0 ;
35322 int val3 ;
35323 int ecode3 = 0 ;
35324 PyObject * obj0 = 0 ;
35325 PyObject * obj1 = 0 ;
35326 PyObject * obj2 = 0 ;
35327 char * kwnames[] = {
35328 (char *) "self",(char *) "x",(char *) "y", NULL
35329 };
35330
35331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35333 if (!SWIG_IsOK(res1)) {
35334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
35335 }
35336 arg1 = reinterpret_cast< wxWindow * >(argp1);
35337 ecode2 = SWIG_AsVal_int(obj1, &val2);
35338 if (!SWIG_IsOK(ecode2)) {
35339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
35340 }
35341 arg2 = static_cast< int >(val2);
35342 ecode3 = SWIG_AsVal_int(obj2, &val3);
35343 if (!SWIG_IsOK(ecode3)) {
35344 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
35345 }
35346 arg3 = static_cast< int >(val3);
35347 {
35348 PyThreadState* __tstate = wxPyBeginAllowThreads();
35349 (arg1)->WarpPointer(arg2,arg3);
35350 wxPyEndAllowThreads(__tstate);
35351 if (PyErr_Occurred()) SWIG_fail;
35352 }
35353 resultobj = SWIG_Py_Void();
35354 return resultobj;
35355 fail:
35356 return NULL;
35357 }
35358
35359
35360 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35361 PyObject *resultobj = 0;
35362 wxWindow *arg1 = (wxWindow *) 0 ;
35363 void *argp1 = 0 ;
35364 int res1 = 0 ;
35365 PyObject *swig_obj[1] ;
35366
35367 if (!args) SWIG_fail;
35368 swig_obj[0] = args;
35369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35370 if (!SWIG_IsOK(res1)) {
35371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35372 }
35373 arg1 = reinterpret_cast< wxWindow * >(argp1);
35374 {
35375 PyThreadState* __tstate = wxPyBeginAllowThreads();
35376 (arg1)->CaptureMouse();
35377 wxPyEndAllowThreads(__tstate);
35378 if (PyErr_Occurred()) SWIG_fail;
35379 }
35380 resultobj = SWIG_Py_Void();
35381 return resultobj;
35382 fail:
35383 return NULL;
35384 }
35385
35386
35387 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35388 PyObject *resultobj = 0;
35389 wxWindow *arg1 = (wxWindow *) 0 ;
35390 void *argp1 = 0 ;
35391 int res1 = 0 ;
35392 PyObject *swig_obj[1] ;
35393
35394 if (!args) SWIG_fail;
35395 swig_obj[0] = args;
35396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35397 if (!SWIG_IsOK(res1)) {
35398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35399 }
35400 arg1 = reinterpret_cast< wxWindow * >(argp1);
35401 {
35402 PyThreadState* __tstate = wxPyBeginAllowThreads();
35403 (arg1)->ReleaseMouse();
35404 wxPyEndAllowThreads(__tstate);
35405 if (PyErr_Occurred()) SWIG_fail;
35406 }
35407 resultobj = SWIG_Py_Void();
35408 return resultobj;
35409 fail:
35410 return NULL;
35411 }
35412
35413
35414 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35415 PyObject *resultobj = 0;
35416 wxWindow *result = 0 ;
35417
35418 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
35419 {
35420 if (!wxPyCheckForApp()) SWIG_fail;
35421 PyThreadState* __tstate = wxPyBeginAllowThreads();
35422 result = (wxWindow *)wxWindow::GetCapture();
35423 wxPyEndAllowThreads(__tstate);
35424 if (PyErr_Occurred()) SWIG_fail;
35425 }
35426 {
35427 resultobj = wxPyMake_wxObject(result, 0);
35428 }
35429 return resultobj;
35430 fail:
35431 return NULL;
35432 }
35433
35434
35435 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35436 PyObject *resultobj = 0;
35437 wxWindow *arg1 = (wxWindow *) 0 ;
35438 bool result;
35439 void *argp1 = 0 ;
35440 int res1 = 0 ;
35441 PyObject *swig_obj[1] ;
35442
35443 if (!args) SWIG_fail;
35444 swig_obj[0] = args;
35445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35446 if (!SWIG_IsOK(res1)) {
35447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
35448 }
35449 arg1 = reinterpret_cast< wxWindow * >(argp1);
35450 {
35451 PyThreadState* __tstate = wxPyBeginAllowThreads();
35452 result = (bool)((wxWindow const *)arg1)->HasCapture();
35453 wxPyEndAllowThreads(__tstate);
35454 if (PyErr_Occurred()) SWIG_fail;
35455 }
35456 {
35457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35458 }
35459 return resultobj;
35460 fail:
35461 return NULL;
35462 }
35463
35464
35465 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35466 PyObject *resultobj = 0;
35467 wxWindow *arg1 = (wxWindow *) 0 ;
35468 bool arg2 = (bool) true ;
35469 wxRect *arg3 = (wxRect *) NULL ;
35470 void *argp1 = 0 ;
35471 int res1 = 0 ;
35472 bool val2 ;
35473 int ecode2 = 0 ;
35474 void *argp3 = 0 ;
35475 int res3 = 0 ;
35476 PyObject * obj0 = 0 ;
35477 PyObject * obj1 = 0 ;
35478 PyObject * obj2 = 0 ;
35479 char * kwnames[] = {
35480 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
35481 };
35482
35483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35485 if (!SWIG_IsOK(res1)) {
35486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
35487 }
35488 arg1 = reinterpret_cast< wxWindow * >(argp1);
35489 if (obj1) {
35490 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35491 if (!SWIG_IsOK(ecode2)) {
35492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
35493 }
35494 arg2 = static_cast< bool >(val2);
35495 }
35496 if (obj2) {
35497 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
35498 if (!SWIG_IsOK(res3)) {
35499 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
35500 }
35501 arg3 = reinterpret_cast< wxRect * >(argp3);
35502 }
35503 {
35504 PyThreadState* __tstate = wxPyBeginAllowThreads();
35505 (arg1)->Refresh(arg2,(wxRect const *)arg3);
35506 wxPyEndAllowThreads(__tstate);
35507 if (PyErr_Occurred()) SWIG_fail;
35508 }
35509 resultobj = SWIG_Py_Void();
35510 return resultobj;
35511 fail:
35512 return NULL;
35513 }
35514
35515
35516 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35517 PyObject *resultobj = 0;
35518 wxWindow *arg1 = (wxWindow *) 0 ;
35519 wxRect *arg2 = 0 ;
35520 bool arg3 = (bool) true ;
35521 void *argp1 = 0 ;
35522 int res1 = 0 ;
35523 wxRect temp2 ;
35524 bool val3 ;
35525 int ecode3 = 0 ;
35526 PyObject * obj0 = 0 ;
35527 PyObject * obj1 = 0 ;
35528 PyObject * obj2 = 0 ;
35529 char * kwnames[] = {
35530 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
35531 };
35532
35533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35535 if (!SWIG_IsOK(res1)) {
35536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
35537 }
35538 arg1 = reinterpret_cast< wxWindow * >(argp1);
35539 {
35540 arg2 = &temp2;
35541 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35542 }
35543 if (obj2) {
35544 ecode3 = SWIG_AsVal_bool(obj2, &val3);
35545 if (!SWIG_IsOK(ecode3)) {
35546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
35547 }
35548 arg3 = static_cast< bool >(val3);
35549 }
35550 {
35551 PyThreadState* __tstate = wxPyBeginAllowThreads();
35552 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
35553 wxPyEndAllowThreads(__tstate);
35554 if (PyErr_Occurred()) SWIG_fail;
35555 }
35556 resultobj = SWIG_Py_Void();
35557 return resultobj;
35558 fail:
35559 return NULL;
35560 }
35561
35562
35563 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35564 PyObject *resultobj = 0;
35565 wxWindow *arg1 = (wxWindow *) 0 ;
35566 void *argp1 = 0 ;
35567 int res1 = 0 ;
35568 PyObject *swig_obj[1] ;
35569
35570 if (!args) SWIG_fail;
35571 swig_obj[0] = args;
35572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35573 if (!SWIG_IsOK(res1)) {
35574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
35575 }
35576 arg1 = reinterpret_cast< wxWindow * >(argp1);
35577 {
35578 PyThreadState* __tstate = wxPyBeginAllowThreads();
35579 (arg1)->Update();
35580 wxPyEndAllowThreads(__tstate);
35581 if (PyErr_Occurred()) SWIG_fail;
35582 }
35583 resultobj = SWIG_Py_Void();
35584 return resultobj;
35585 fail:
35586 return NULL;
35587 }
35588
35589
35590 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35591 PyObject *resultobj = 0;
35592 wxWindow *arg1 = (wxWindow *) 0 ;
35593 void *argp1 = 0 ;
35594 int res1 = 0 ;
35595 PyObject *swig_obj[1] ;
35596
35597 if (!args) SWIG_fail;
35598 swig_obj[0] = args;
35599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35600 if (!SWIG_IsOK(res1)) {
35601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35602 }
35603 arg1 = reinterpret_cast< wxWindow * >(argp1);
35604 {
35605 PyThreadState* __tstate = wxPyBeginAllowThreads();
35606 (arg1)->ClearBackground();
35607 wxPyEndAllowThreads(__tstate);
35608 if (PyErr_Occurred()) SWIG_fail;
35609 }
35610 resultobj = SWIG_Py_Void();
35611 return resultobj;
35612 fail:
35613 return NULL;
35614 }
35615
35616
35617 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35618 PyObject *resultobj = 0;
35619 wxWindow *arg1 = (wxWindow *) 0 ;
35620 void *argp1 = 0 ;
35621 int res1 = 0 ;
35622 PyObject *swig_obj[1] ;
35623
35624 if (!args) SWIG_fail;
35625 swig_obj[0] = args;
35626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35627 if (!SWIG_IsOK(res1)) {
35628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35629 }
35630 arg1 = reinterpret_cast< wxWindow * >(argp1);
35631 {
35632 PyThreadState* __tstate = wxPyBeginAllowThreads();
35633 (arg1)->Freeze();
35634 wxPyEndAllowThreads(__tstate);
35635 if (PyErr_Occurred()) SWIG_fail;
35636 }
35637 resultobj = SWIG_Py_Void();
35638 return resultobj;
35639 fail:
35640 return NULL;
35641 }
35642
35643
35644 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35645 PyObject *resultobj = 0;
35646 wxWindow *arg1 = (wxWindow *) 0 ;
35647 bool result;
35648 void *argp1 = 0 ;
35649 int res1 = 0 ;
35650 PyObject *swig_obj[1] ;
35651
35652 if (!args) SWIG_fail;
35653 swig_obj[0] = args;
35654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35655 if (!SWIG_IsOK(res1)) {
35656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35657 }
35658 arg1 = reinterpret_cast< wxWindow * >(argp1);
35659 {
35660 PyThreadState* __tstate = wxPyBeginAllowThreads();
35661 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35662 wxPyEndAllowThreads(__tstate);
35663 if (PyErr_Occurred()) SWIG_fail;
35664 }
35665 {
35666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35667 }
35668 return resultobj;
35669 fail:
35670 return NULL;
35671 }
35672
35673
35674 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35675 PyObject *resultobj = 0;
35676 wxWindow *arg1 = (wxWindow *) 0 ;
35677 void *argp1 = 0 ;
35678 int res1 = 0 ;
35679 PyObject *swig_obj[1] ;
35680
35681 if (!args) SWIG_fail;
35682 swig_obj[0] = args;
35683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35684 if (!SWIG_IsOK(res1)) {
35685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35686 }
35687 arg1 = reinterpret_cast< wxWindow * >(argp1);
35688 {
35689 PyThreadState* __tstate = wxPyBeginAllowThreads();
35690 (arg1)->Thaw();
35691 wxPyEndAllowThreads(__tstate);
35692 if (PyErr_Occurred()) SWIG_fail;
35693 }
35694 resultobj = SWIG_Py_Void();
35695 return resultobj;
35696 fail:
35697 return NULL;
35698 }
35699
35700
35701 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35702 PyObject *resultobj = 0;
35703 wxWindow *arg1 = (wxWindow *) 0 ;
35704 wxDC *arg2 = 0 ;
35705 void *argp1 = 0 ;
35706 int res1 = 0 ;
35707 void *argp2 = 0 ;
35708 int res2 = 0 ;
35709 PyObject * obj0 = 0 ;
35710 PyObject * obj1 = 0 ;
35711 char * kwnames[] = {
35712 (char *) "self",(char *) "dc", NULL
35713 };
35714
35715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35717 if (!SWIG_IsOK(res1)) {
35718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35719 }
35720 arg1 = reinterpret_cast< wxWindow * >(argp1);
35721 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35722 if (!SWIG_IsOK(res2)) {
35723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35724 }
35725 if (!argp2) {
35726 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35727 }
35728 arg2 = reinterpret_cast< wxDC * >(argp2);
35729 {
35730 PyThreadState* __tstate = wxPyBeginAllowThreads();
35731 (arg1)->PrepareDC(*arg2);
35732 wxPyEndAllowThreads(__tstate);
35733 if (PyErr_Occurred()) SWIG_fail;
35734 }
35735 resultobj = SWIG_Py_Void();
35736 return resultobj;
35737 fail:
35738 return NULL;
35739 }
35740
35741
35742 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35743 PyObject *resultobj = 0;
35744 wxWindow *arg1 = (wxWindow *) 0 ;
35745 bool result;
35746 void *argp1 = 0 ;
35747 int res1 = 0 ;
35748 PyObject *swig_obj[1] ;
35749
35750 if (!args) SWIG_fail;
35751 swig_obj[0] = args;
35752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35753 if (!SWIG_IsOK(res1)) {
35754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
35755 }
35756 arg1 = reinterpret_cast< wxWindow * >(argp1);
35757 {
35758 PyThreadState* __tstate = wxPyBeginAllowThreads();
35759 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
35760 wxPyEndAllowThreads(__tstate);
35761 if (PyErr_Occurred()) SWIG_fail;
35762 }
35763 {
35764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35765 }
35766 return resultobj;
35767 fail:
35768 return NULL;
35769 }
35770
35771
35772 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35773 PyObject *resultobj = 0;
35774 wxWindow *arg1 = (wxWindow *) 0 ;
35775 wxRegion *result = 0 ;
35776 void *argp1 = 0 ;
35777 int res1 = 0 ;
35778 PyObject *swig_obj[1] ;
35779
35780 if (!args) SWIG_fail;
35781 swig_obj[0] = args;
35782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35783 if (!SWIG_IsOK(res1)) {
35784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35785 }
35786 arg1 = reinterpret_cast< wxWindow * >(argp1);
35787 {
35788 PyThreadState* __tstate = wxPyBeginAllowThreads();
35789 {
35790 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35791 result = (wxRegion *) &_result_ref;
35792 }
35793 wxPyEndAllowThreads(__tstate);
35794 if (PyErr_Occurred()) SWIG_fail;
35795 }
35796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35797 return resultobj;
35798 fail:
35799 return NULL;
35800 }
35801
35802
35803 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35804 PyObject *resultobj = 0;
35805 wxWindow *arg1 = (wxWindow *) 0 ;
35806 wxRect result;
35807 void *argp1 = 0 ;
35808 int res1 = 0 ;
35809 PyObject *swig_obj[1] ;
35810
35811 if (!args) SWIG_fail;
35812 swig_obj[0] = args;
35813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35814 if (!SWIG_IsOK(res1)) {
35815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35816 }
35817 arg1 = reinterpret_cast< wxWindow * >(argp1);
35818 {
35819 PyThreadState* __tstate = wxPyBeginAllowThreads();
35820 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35821 wxPyEndAllowThreads(__tstate);
35822 if (PyErr_Occurred()) SWIG_fail;
35823 }
35824 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35825 return resultobj;
35826 fail:
35827 return NULL;
35828 }
35829
35830
35831 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35832 PyObject *resultobj = 0;
35833 wxWindow *arg1 = (wxWindow *) 0 ;
35834 int arg2 ;
35835 int arg3 ;
35836 int arg4 = (int) 1 ;
35837 int arg5 = (int) 1 ;
35838 bool result;
35839 void *argp1 = 0 ;
35840 int res1 = 0 ;
35841 int val2 ;
35842 int ecode2 = 0 ;
35843 int val3 ;
35844 int ecode3 = 0 ;
35845 int val4 ;
35846 int ecode4 = 0 ;
35847 int val5 ;
35848 int ecode5 = 0 ;
35849 PyObject * obj0 = 0 ;
35850 PyObject * obj1 = 0 ;
35851 PyObject * obj2 = 0 ;
35852 PyObject * obj3 = 0 ;
35853 PyObject * obj4 = 0 ;
35854 char * kwnames[] = {
35855 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35856 };
35857
35858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35860 if (!SWIG_IsOK(res1)) {
35861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35862 }
35863 arg1 = reinterpret_cast< wxWindow * >(argp1);
35864 ecode2 = SWIG_AsVal_int(obj1, &val2);
35865 if (!SWIG_IsOK(ecode2)) {
35866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35867 }
35868 arg2 = static_cast< int >(val2);
35869 ecode3 = SWIG_AsVal_int(obj2, &val3);
35870 if (!SWIG_IsOK(ecode3)) {
35871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35872 }
35873 arg3 = static_cast< int >(val3);
35874 if (obj3) {
35875 ecode4 = SWIG_AsVal_int(obj3, &val4);
35876 if (!SWIG_IsOK(ecode4)) {
35877 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35878 }
35879 arg4 = static_cast< int >(val4);
35880 }
35881 if (obj4) {
35882 ecode5 = SWIG_AsVal_int(obj4, &val5);
35883 if (!SWIG_IsOK(ecode5)) {
35884 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35885 }
35886 arg5 = static_cast< int >(val5);
35887 }
35888 {
35889 PyThreadState* __tstate = wxPyBeginAllowThreads();
35890 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35891 wxPyEndAllowThreads(__tstate);
35892 if (PyErr_Occurred()) SWIG_fail;
35893 }
35894 {
35895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35896 }
35897 return resultobj;
35898 fail:
35899 return NULL;
35900 }
35901
35902
35903 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35904 PyObject *resultobj = 0;
35905 wxWindow *arg1 = (wxWindow *) 0 ;
35906 wxPoint *arg2 = 0 ;
35907 bool result;
35908 void *argp1 = 0 ;
35909 int res1 = 0 ;
35910 wxPoint temp2 ;
35911 PyObject * obj0 = 0 ;
35912 PyObject * obj1 = 0 ;
35913 char * kwnames[] = {
35914 (char *) "self",(char *) "pt", NULL
35915 };
35916
35917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35919 if (!SWIG_IsOK(res1)) {
35920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35921 }
35922 arg1 = reinterpret_cast< wxWindow * >(argp1);
35923 {
35924 arg2 = &temp2;
35925 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35926 }
35927 {
35928 PyThreadState* __tstate = wxPyBeginAllowThreads();
35929 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35930 wxPyEndAllowThreads(__tstate);
35931 if (PyErr_Occurred()) SWIG_fail;
35932 }
35933 {
35934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35935 }
35936 return resultobj;
35937 fail:
35938 return NULL;
35939 }
35940
35941
35942 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35943 PyObject *resultobj = 0;
35944 wxWindow *arg1 = (wxWindow *) 0 ;
35945 wxRect *arg2 = 0 ;
35946 bool result;
35947 void *argp1 = 0 ;
35948 int res1 = 0 ;
35949 wxRect temp2 ;
35950 PyObject * obj0 = 0 ;
35951 PyObject * obj1 = 0 ;
35952 char * kwnames[] = {
35953 (char *) "self",(char *) "rect", NULL
35954 };
35955
35956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35958 if (!SWIG_IsOK(res1)) {
35959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35960 }
35961 arg1 = reinterpret_cast< wxWindow * >(argp1);
35962 {
35963 arg2 = &temp2;
35964 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35965 }
35966 {
35967 PyThreadState* __tstate = wxPyBeginAllowThreads();
35968 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35969 wxPyEndAllowThreads(__tstate);
35970 if (PyErr_Occurred()) SWIG_fail;
35971 }
35972 {
35973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35974 }
35975 return resultobj;
35976 fail:
35977 return NULL;
35978 }
35979
35980
35981 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35982 PyObject *resultobj = 0;
35983 wxWindow *arg1 = (wxWindow *) 0 ;
35984 SwigValueWrapper<wxVisualAttributes > result;
35985 void *argp1 = 0 ;
35986 int res1 = 0 ;
35987 PyObject *swig_obj[1] ;
35988
35989 if (!args) SWIG_fail;
35990 swig_obj[0] = args;
35991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35992 if (!SWIG_IsOK(res1)) {
35993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35994 }
35995 arg1 = reinterpret_cast< wxWindow * >(argp1);
35996 {
35997 PyThreadState* __tstate = wxPyBeginAllowThreads();
35998 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35999 wxPyEndAllowThreads(__tstate);
36000 if (PyErr_Occurred()) SWIG_fail;
36001 }
36002 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
36003 return resultobj;
36004 fail:
36005 return NULL;
36006 }
36007
36008
36009 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36010 PyObject *resultobj = 0;
36011 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36012 SwigValueWrapper<wxVisualAttributes > result;
36013 int val1 ;
36014 int ecode1 = 0 ;
36015 PyObject * obj0 = 0 ;
36016 char * kwnames[] = {
36017 (char *) "variant", NULL
36018 };
36019
36020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
36021 if (obj0) {
36022 ecode1 = SWIG_AsVal_int(obj0, &val1);
36023 if (!SWIG_IsOK(ecode1)) {
36024 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
36025 }
36026 arg1 = static_cast< wxWindowVariant >(val1);
36027 }
36028 {
36029 if (!wxPyCheckForApp()) SWIG_fail;
36030 PyThreadState* __tstate = wxPyBeginAllowThreads();
36031 result = wxWindow::GetClassDefaultAttributes(arg1);
36032 wxPyEndAllowThreads(__tstate);
36033 if (PyErr_Occurred()) SWIG_fail;
36034 }
36035 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
36036 return resultobj;
36037 fail:
36038 return NULL;
36039 }
36040
36041
36042 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36043 PyObject *resultobj = 0;
36044 wxWindow *arg1 = (wxWindow *) 0 ;
36045 wxColour *arg2 = 0 ;
36046 bool result;
36047 void *argp1 = 0 ;
36048 int res1 = 0 ;
36049 wxColour temp2 ;
36050 PyObject * obj0 = 0 ;
36051 PyObject * obj1 = 0 ;
36052 char * kwnames[] = {
36053 (char *) "self",(char *) "colour", NULL
36054 };
36055
36056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36058 if (!SWIG_IsOK(res1)) {
36059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36060 }
36061 arg1 = reinterpret_cast< wxWindow * >(argp1);
36062 {
36063 arg2 = &temp2;
36064 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36065 }
36066 {
36067 PyThreadState* __tstate = wxPyBeginAllowThreads();
36068 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
36069 wxPyEndAllowThreads(__tstate);
36070 if (PyErr_Occurred()) SWIG_fail;
36071 }
36072 {
36073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36074 }
36075 return resultobj;
36076 fail:
36077 return NULL;
36078 }
36079
36080
36081 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36082 PyObject *resultobj = 0;
36083 wxWindow *arg1 = (wxWindow *) 0 ;
36084 wxColour *arg2 = 0 ;
36085 void *argp1 = 0 ;
36086 int res1 = 0 ;
36087 wxColour temp2 ;
36088 PyObject * obj0 = 0 ;
36089 PyObject * obj1 = 0 ;
36090 char * kwnames[] = {
36091 (char *) "self",(char *) "colour", NULL
36092 };
36093
36094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36096 if (!SWIG_IsOK(res1)) {
36097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36098 }
36099 arg1 = reinterpret_cast< wxWindow * >(argp1);
36100 {
36101 arg2 = &temp2;
36102 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36103 }
36104 {
36105 PyThreadState* __tstate = wxPyBeginAllowThreads();
36106 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
36107 wxPyEndAllowThreads(__tstate);
36108 if (PyErr_Occurred()) SWIG_fail;
36109 }
36110 resultobj = SWIG_Py_Void();
36111 return resultobj;
36112 fail:
36113 return NULL;
36114 }
36115
36116
36117 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36118 PyObject *resultobj = 0;
36119 wxWindow *arg1 = (wxWindow *) 0 ;
36120 wxColour *arg2 = 0 ;
36121 bool result;
36122 void *argp1 = 0 ;
36123 int res1 = 0 ;
36124 wxColour temp2 ;
36125 PyObject * obj0 = 0 ;
36126 PyObject * obj1 = 0 ;
36127 char * kwnames[] = {
36128 (char *) "self",(char *) "colour", NULL
36129 };
36130
36131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",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_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36135 }
36136 arg1 = reinterpret_cast< wxWindow * >(argp1);
36137 {
36138 arg2 = &temp2;
36139 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36140 }
36141 {
36142 PyThreadState* __tstate = wxPyBeginAllowThreads();
36143 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
36144 wxPyEndAllowThreads(__tstate);
36145 if (PyErr_Occurred()) SWIG_fail;
36146 }
36147 {
36148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36149 }
36150 return resultobj;
36151 fail:
36152 return NULL;
36153 }
36154
36155
36156 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36157 PyObject *resultobj = 0;
36158 wxWindow *arg1 = (wxWindow *) 0 ;
36159 wxColour *arg2 = 0 ;
36160 void *argp1 = 0 ;
36161 int res1 = 0 ;
36162 wxColour temp2 ;
36163 PyObject * obj0 = 0 ;
36164 PyObject * obj1 = 0 ;
36165 char * kwnames[] = {
36166 (char *) "self",(char *) "colour", NULL
36167 };
36168
36169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36171 if (!SWIG_IsOK(res1)) {
36172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36173 }
36174 arg1 = reinterpret_cast< wxWindow * >(argp1);
36175 {
36176 arg2 = &temp2;
36177 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36178 }
36179 {
36180 PyThreadState* __tstate = wxPyBeginAllowThreads();
36181 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
36182 wxPyEndAllowThreads(__tstate);
36183 if (PyErr_Occurred()) SWIG_fail;
36184 }
36185 resultobj = SWIG_Py_Void();
36186 return resultobj;
36187 fail:
36188 return NULL;
36189 }
36190
36191
36192 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36193 PyObject *resultobj = 0;
36194 wxWindow *arg1 = (wxWindow *) 0 ;
36195 wxColour result;
36196 void *argp1 = 0 ;
36197 int res1 = 0 ;
36198 PyObject *swig_obj[1] ;
36199
36200 if (!args) SWIG_fail;
36201 swig_obj[0] = args;
36202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36203 if (!SWIG_IsOK(res1)) {
36204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36205 }
36206 arg1 = reinterpret_cast< wxWindow * >(argp1);
36207 {
36208 PyThreadState* __tstate = wxPyBeginAllowThreads();
36209 result = ((wxWindow const *)arg1)->GetBackgroundColour();
36210 wxPyEndAllowThreads(__tstate);
36211 if (PyErr_Occurred()) SWIG_fail;
36212 }
36213 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36214 return resultobj;
36215 fail:
36216 return NULL;
36217 }
36218
36219
36220 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36221 PyObject *resultobj = 0;
36222 wxWindow *arg1 = (wxWindow *) 0 ;
36223 wxColour result;
36224 void *argp1 = 0 ;
36225 int res1 = 0 ;
36226 PyObject *swig_obj[1] ;
36227
36228 if (!args) SWIG_fail;
36229 swig_obj[0] = args;
36230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36231 if (!SWIG_IsOK(res1)) {
36232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36233 }
36234 arg1 = reinterpret_cast< wxWindow * >(argp1);
36235 {
36236 PyThreadState* __tstate = wxPyBeginAllowThreads();
36237 result = ((wxWindow const *)arg1)->GetForegroundColour();
36238 wxPyEndAllowThreads(__tstate);
36239 if (PyErr_Occurred()) SWIG_fail;
36240 }
36241 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36242 return resultobj;
36243 fail:
36244 return NULL;
36245 }
36246
36247
36248 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36249 PyObject *resultobj = 0;
36250 wxWindow *arg1 = (wxWindow *) 0 ;
36251 bool result;
36252 void *argp1 = 0 ;
36253 int res1 = 0 ;
36254 PyObject *swig_obj[1] ;
36255
36256 if (!args) SWIG_fail;
36257 swig_obj[0] = args;
36258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36259 if (!SWIG_IsOK(res1)) {
36260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36261 }
36262 arg1 = reinterpret_cast< wxWindow * >(argp1);
36263 {
36264 PyThreadState* __tstate = wxPyBeginAllowThreads();
36265 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
36266 wxPyEndAllowThreads(__tstate);
36267 if (PyErr_Occurred()) SWIG_fail;
36268 }
36269 {
36270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36271 }
36272 return resultobj;
36273 fail:
36274 return NULL;
36275 }
36276
36277
36278 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36279 PyObject *resultobj = 0;
36280 wxWindow *arg1 = (wxWindow *) 0 ;
36281 bool result;
36282 void *argp1 = 0 ;
36283 int res1 = 0 ;
36284 PyObject *swig_obj[1] ;
36285
36286 if (!args) SWIG_fail;
36287 swig_obj[0] = args;
36288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36289 if (!SWIG_IsOK(res1)) {
36290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
36291 }
36292 arg1 = reinterpret_cast< wxWindow * >(argp1);
36293 {
36294 PyThreadState* __tstate = wxPyBeginAllowThreads();
36295 result = (bool)((wxWindow const *)arg1)->UseBgCol();
36296 wxPyEndAllowThreads(__tstate);
36297 if (PyErr_Occurred()) SWIG_fail;
36298 }
36299 {
36300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36301 }
36302 return resultobj;
36303 fail:
36304 return NULL;
36305 }
36306
36307
36308 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36309 PyObject *resultobj = 0;
36310 wxWindow *arg1 = (wxWindow *) 0 ;
36311 wxBackgroundStyle arg2 ;
36312 bool result;
36313 void *argp1 = 0 ;
36314 int res1 = 0 ;
36315 int val2 ;
36316 int ecode2 = 0 ;
36317 PyObject * obj0 = 0 ;
36318 PyObject * obj1 = 0 ;
36319 char * kwnames[] = {
36320 (char *) "self",(char *) "style", NULL
36321 };
36322
36323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36325 if (!SWIG_IsOK(res1)) {
36326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36327 }
36328 arg1 = reinterpret_cast< wxWindow * >(argp1);
36329 ecode2 = SWIG_AsVal_int(obj1, &val2);
36330 if (!SWIG_IsOK(ecode2)) {
36331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
36332 }
36333 arg2 = static_cast< wxBackgroundStyle >(val2);
36334 {
36335 PyThreadState* __tstate = wxPyBeginAllowThreads();
36336 result = (bool)(arg1)->SetBackgroundStyle(arg2);
36337 wxPyEndAllowThreads(__tstate);
36338 if (PyErr_Occurred()) SWIG_fail;
36339 }
36340 {
36341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36342 }
36343 return resultobj;
36344 fail:
36345 return NULL;
36346 }
36347
36348
36349 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36350 PyObject *resultobj = 0;
36351 wxWindow *arg1 = (wxWindow *) 0 ;
36352 wxBackgroundStyle result;
36353 void *argp1 = 0 ;
36354 int res1 = 0 ;
36355 PyObject *swig_obj[1] ;
36356
36357 if (!args) SWIG_fail;
36358 swig_obj[0] = args;
36359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36360 if (!SWIG_IsOK(res1)) {
36361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36362 }
36363 arg1 = reinterpret_cast< wxWindow * >(argp1);
36364 {
36365 PyThreadState* __tstate = wxPyBeginAllowThreads();
36366 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
36367 wxPyEndAllowThreads(__tstate);
36368 if (PyErr_Occurred()) SWIG_fail;
36369 }
36370 resultobj = SWIG_From_int(static_cast< int >(result));
36371 return resultobj;
36372 fail:
36373 return NULL;
36374 }
36375
36376
36377 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36378 PyObject *resultobj = 0;
36379 wxWindow *arg1 = (wxWindow *) 0 ;
36380 bool result;
36381 void *argp1 = 0 ;
36382 int res1 = 0 ;
36383 PyObject *swig_obj[1] ;
36384
36385 if (!args) SWIG_fail;
36386 swig_obj[0] = args;
36387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36388 if (!SWIG_IsOK(res1)) {
36389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
36390 }
36391 arg1 = reinterpret_cast< wxWindow * >(argp1);
36392 {
36393 PyThreadState* __tstate = wxPyBeginAllowThreads();
36394 result = (bool)(arg1)->HasTransparentBackground();
36395 wxPyEndAllowThreads(__tstate);
36396 if (PyErr_Occurred()) SWIG_fail;
36397 }
36398 {
36399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36400 }
36401 return resultobj;
36402 fail:
36403 return NULL;
36404 }
36405
36406
36407 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36408 PyObject *resultobj = 0;
36409 wxWindow *arg1 = (wxWindow *) 0 ;
36410 wxCursor *arg2 = 0 ;
36411 bool result;
36412 void *argp1 = 0 ;
36413 int res1 = 0 ;
36414 void *argp2 = 0 ;
36415 int res2 = 0 ;
36416 PyObject * obj0 = 0 ;
36417 PyObject * obj1 = 0 ;
36418 char * kwnames[] = {
36419 (char *) "self",(char *) "cursor", NULL
36420 };
36421
36422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
36423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36424 if (!SWIG_IsOK(res1)) {
36425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36426 }
36427 arg1 = reinterpret_cast< wxWindow * >(argp1);
36428 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
36429 if (!SWIG_IsOK(res2)) {
36430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36431 }
36432 if (!argp2) {
36433 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36434 }
36435 arg2 = reinterpret_cast< wxCursor * >(argp2);
36436 {
36437 PyThreadState* __tstate = wxPyBeginAllowThreads();
36438 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
36439 wxPyEndAllowThreads(__tstate);
36440 if (PyErr_Occurred()) SWIG_fail;
36441 }
36442 {
36443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36444 }
36445 return resultobj;
36446 fail:
36447 return NULL;
36448 }
36449
36450
36451 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36452 PyObject *resultobj = 0;
36453 wxWindow *arg1 = (wxWindow *) 0 ;
36454 wxCursor result;
36455 void *argp1 = 0 ;
36456 int res1 = 0 ;
36457 PyObject *swig_obj[1] ;
36458
36459 if (!args) SWIG_fail;
36460 swig_obj[0] = args;
36461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36462 if (!SWIG_IsOK(res1)) {
36463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36464 }
36465 arg1 = reinterpret_cast< wxWindow * >(argp1);
36466 {
36467 PyThreadState* __tstate = wxPyBeginAllowThreads();
36468 result = (arg1)->GetCursor();
36469 wxPyEndAllowThreads(__tstate);
36470 if (PyErr_Occurred()) SWIG_fail;
36471 }
36472 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
36473 return resultobj;
36474 fail:
36475 return NULL;
36476 }
36477
36478
36479 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36480 PyObject *resultobj = 0;
36481 wxWindow *arg1 = (wxWindow *) 0 ;
36482 wxFont *arg2 = 0 ;
36483 bool result;
36484 void *argp1 = 0 ;
36485 int res1 = 0 ;
36486 void *argp2 = 0 ;
36487 int res2 = 0 ;
36488 PyObject * obj0 = 0 ;
36489 PyObject * obj1 = 0 ;
36490 char * kwnames[] = {
36491 (char *) "self",(char *) "font", NULL
36492 };
36493
36494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
36495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36496 if (!SWIG_IsOK(res1)) {
36497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36498 }
36499 arg1 = reinterpret_cast< wxWindow * >(argp1);
36500 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36501 if (!SWIG_IsOK(res2)) {
36502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36503 }
36504 if (!argp2) {
36505 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36506 }
36507 arg2 = reinterpret_cast< wxFont * >(argp2);
36508 {
36509 PyThreadState* __tstate = wxPyBeginAllowThreads();
36510 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
36511 wxPyEndAllowThreads(__tstate);
36512 if (PyErr_Occurred()) SWIG_fail;
36513 }
36514 {
36515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36516 }
36517 return resultobj;
36518 fail:
36519 return NULL;
36520 }
36521
36522
36523 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36524 PyObject *resultobj = 0;
36525 wxWindow *arg1 = (wxWindow *) 0 ;
36526 wxFont *arg2 = 0 ;
36527 void *argp1 = 0 ;
36528 int res1 = 0 ;
36529 void *argp2 = 0 ;
36530 int res2 = 0 ;
36531 PyObject * obj0 = 0 ;
36532 PyObject * obj1 = 0 ;
36533 char * kwnames[] = {
36534 (char *) "self",(char *) "font", NULL
36535 };
36536
36537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
36538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36539 if (!SWIG_IsOK(res1)) {
36540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36541 }
36542 arg1 = reinterpret_cast< wxWindow * >(argp1);
36543 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36544 if (!SWIG_IsOK(res2)) {
36545 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36546 }
36547 if (!argp2) {
36548 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36549 }
36550 arg2 = reinterpret_cast< wxFont * >(argp2);
36551 {
36552 PyThreadState* __tstate = wxPyBeginAllowThreads();
36553 (arg1)->SetOwnFont((wxFont const &)*arg2);
36554 wxPyEndAllowThreads(__tstate);
36555 if (PyErr_Occurred()) SWIG_fail;
36556 }
36557 resultobj = SWIG_Py_Void();
36558 return resultobj;
36559 fail:
36560 return NULL;
36561 }
36562
36563
36564 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36565 PyObject *resultobj = 0;
36566 wxWindow *arg1 = (wxWindow *) 0 ;
36567 wxFont result;
36568 void *argp1 = 0 ;
36569 int res1 = 0 ;
36570 PyObject *swig_obj[1] ;
36571
36572 if (!args) SWIG_fail;
36573 swig_obj[0] = args;
36574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36575 if (!SWIG_IsOK(res1)) {
36576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36577 }
36578 arg1 = reinterpret_cast< wxWindow * >(argp1);
36579 {
36580 PyThreadState* __tstate = wxPyBeginAllowThreads();
36581 result = (arg1)->GetFont();
36582 wxPyEndAllowThreads(__tstate);
36583 if (PyErr_Occurred()) SWIG_fail;
36584 }
36585 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
36586 return resultobj;
36587 fail:
36588 return NULL;
36589 }
36590
36591
36592 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36593 PyObject *resultobj = 0;
36594 wxWindow *arg1 = (wxWindow *) 0 ;
36595 wxCaret *arg2 = (wxCaret *) 0 ;
36596 void *argp1 = 0 ;
36597 int res1 = 0 ;
36598 int res2 = 0 ;
36599 PyObject * obj0 = 0 ;
36600 PyObject * obj1 = 0 ;
36601 char * kwnames[] = {
36602 (char *) "self",(char *) "caret", NULL
36603 };
36604
36605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
36606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36607 if (!SWIG_IsOK(res1)) {
36608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36609 }
36610 arg1 = reinterpret_cast< wxWindow * >(argp1);
36611 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36612 if (!SWIG_IsOK(res2)) {
36613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36614 }
36615 {
36616 PyThreadState* __tstate = wxPyBeginAllowThreads();
36617 (arg1)->SetCaret(arg2);
36618 wxPyEndAllowThreads(__tstate);
36619 if (PyErr_Occurred()) SWIG_fail;
36620 }
36621 resultobj = SWIG_Py_Void();
36622 return resultobj;
36623 fail:
36624 return NULL;
36625 }
36626
36627
36628 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36629 PyObject *resultobj = 0;
36630 wxWindow *arg1 = (wxWindow *) 0 ;
36631 wxCaret *result = 0 ;
36632 void *argp1 = 0 ;
36633 int res1 = 0 ;
36634 PyObject *swig_obj[1] ;
36635
36636 if (!args) SWIG_fail;
36637 swig_obj[0] = args;
36638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36639 if (!SWIG_IsOK(res1)) {
36640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36641 }
36642 arg1 = reinterpret_cast< wxWindow * >(argp1);
36643 {
36644 PyThreadState* __tstate = wxPyBeginAllowThreads();
36645 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36646 wxPyEndAllowThreads(__tstate);
36647 if (PyErr_Occurred()) SWIG_fail;
36648 }
36649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36650 return resultobj;
36651 fail:
36652 return NULL;
36653 }
36654
36655
36656 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36657 PyObject *resultobj = 0;
36658 wxWindow *arg1 = (wxWindow *) 0 ;
36659 int result;
36660 void *argp1 = 0 ;
36661 int res1 = 0 ;
36662 PyObject *swig_obj[1] ;
36663
36664 if (!args) SWIG_fail;
36665 swig_obj[0] = args;
36666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36667 if (!SWIG_IsOK(res1)) {
36668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36669 }
36670 arg1 = reinterpret_cast< wxWindow * >(argp1);
36671 {
36672 PyThreadState* __tstate = wxPyBeginAllowThreads();
36673 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36674 wxPyEndAllowThreads(__tstate);
36675 if (PyErr_Occurred()) SWIG_fail;
36676 }
36677 resultobj = SWIG_From_int(static_cast< int >(result));
36678 return resultobj;
36679 fail:
36680 return NULL;
36681 }
36682
36683
36684 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36685 PyObject *resultobj = 0;
36686 wxWindow *arg1 = (wxWindow *) 0 ;
36687 int result;
36688 void *argp1 = 0 ;
36689 int res1 = 0 ;
36690 PyObject *swig_obj[1] ;
36691
36692 if (!args) SWIG_fail;
36693 swig_obj[0] = args;
36694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36695 if (!SWIG_IsOK(res1)) {
36696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36697 }
36698 arg1 = reinterpret_cast< wxWindow * >(argp1);
36699 {
36700 PyThreadState* __tstate = wxPyBeginAllowThreads();
36701 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36702 wxPyEndAllowThreads(__tstate);
36703 if (PyErr_Occurred()) SWIG_fail;
36704 }
36705 resultobj = SWIG_From_int(static_cast< int >(result));
36706 return resultobj;
36707 fail:
36708 return NULL;
36709 }
36710
36711
36712 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36713 PyObject *resultobj = 0;
36714 wxWindow *arg1 = (wxWindow *) 0 ;
36715 wxString *arg2 = 0 ;
36716 int *arg3 = (int *) 0 ;
36717 int *arg4 = (int *) 0 ;
36718 void *argp1 = 0 ;
36719 int res1 = 0 ;
36720 bool temp2 = false ;
36721 int temp3 ;
36722 int res3 = SWIG_TMPOBJ ;
36723 int temp4 ;
36724 int res4 = SWIG_TMPOBJ ;
36725 PyObject * obj0 = 0 ;
36726 PyObject * obj1 = 0 ;
36727 char * kwnames[] = {
36728 (char *) "self",(char *) "string", NULL
36729 };
36730
36731 arg3 = &temp3;
36732 arg4 = &temp4;
36733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36735 if (!SWIG_IsOK(res1)) {
36736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36737 }
36738 arg1 = reinterpret_cast< wxWindow * >(argp1);
36739 {
36740 arg2 = wxString_in_helper(obj1);
36741 if (arg2 == NULL) SWIG_fail;
36742 temp2 = true;
36743 }
36744 {
36745 PyThreadState* __tstate = wxPyBeginAllowThreads();
36746 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36747 wxPyEndAllowThreads(__tstate);
36748 if (PyErr_Occurred()) SWIG_fail;
36749 }
36750 resultobj = SWIG_Py_Void();
36751 if (SWIG_IsTmpObj(res3)) {
36752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36753 } else {
36754 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36756 }
36757 if (SWIG_IsTmpObj(res4)) {
36758 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36759 } else {
36760 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36761 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36762 }
36763 {
36764 if (temp2)
36765 delete arg2;
36766 }
36767 return resultobj;
36768 fail:
36769 {
36770 if (temp2)
36771 delete arg2;
36772 }
36773 return NULL;
36774 }
36775
36776
36777 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36778 PyObject *resultobj = 0;
36779 wxWindow *arg1 = (wxWindow *) 0 ;
36780 wxString *arg2 = 0 ;
36781 int *arg3 = (int *) 0 ;
36782 int *arg4 = (int *) 0 ;
36783 int *arg5 = (int *) 0 ;
36784 int *arg6 = (int *) 0 ;
36785 wxFont *arg7 = (wxFont *) NULL ;
36786 void *argp1 = 0 ;
36787 int res1 = 0 ;
36788 bool temp2 = false ;
36789 int temp3 ;
36790 int res3 = SWIG_TMPOBJ ;
36791 int temp4 ;
36792 int res4 = SWIG_TMPOBJ ;
36793 int temp5 ;
36794 int res5 = SWIG_TMPOBJ ;
36795 int temp6 ;
36796 int res6 = SWIG_TMPOBJ ;
36797 void *argp7 = 0 ;
36798 int res7 = 0 ;
36799 PyObject * obj0 = 0 ;
36800 PyObject * obj1 = 0 ;
36801 PyObject * obj2 = 0 ;
36802 char * kwnames[] = {
36803 (char *) "self",(char *) "string",(char *) "font", NULL
36804 };
36805
36806 arg3 = &temp3;
36807 arg4 = &temp4;
36808 arg5 = &temp5;
36809 arg6 = &temp6;
36810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36812 if (!SWIG_IsOK(res1)) {
36813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36814 }
36815 arg1 = reinterpret_cast< wxWindow * >(argp1);
36816 {
36817 arg2 = wxString_in_helper(obj1);
36818 if (arg2 == NULL) SWIG_fail;
36819 temp2 = true;
36820 }
36821 if (obj2) {
36822 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36823 if (!SWIG_IsOK(res7)) {
36824 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36825 }
36826 arg7 = reinterpret_cast< wxFont * >(argp7);
36827 }
36828 {
36829 PyThreadState* __tstate = wxPyBeginAllowThreads();
36830 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36831 wxPyEndAllowThreads(__tstate);
36832 if (PyErr_Occurred()) SWIG_fail;
36833 }
36834 resultobj = SWIG_Py_Void();
36835 if (SWIG_IsTmpObj(res3)) {
36836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36837 } else {
36838 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36840 }
36841 if (SWIG_IsTmpObj(res4)) {
36842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36843 } else {
36844 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36846 }
36847 if (SWIG_IsTmpObj(res5)) {
36848 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36849 } else {
36850 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36851 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36852 }
36853 if (SWIG_IsTmpObj(res6)) {
36854 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36855 } else {
36856 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36857 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36858 }
36859 {
36860 if (temp2)
36861 delete arg2;
36862 }
36863 return resultobj;
36864 fail:
36865 {
36866 if (temp2)
36867 delete arg2;
36868 }
36869 return NULL;
36870 }
36871
36872
36873 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36874 PyObject *resultobj = 0;
36875 wxWindow *arg1 = (wxWindow *) 0 ;
36876 int *arg2 = (int *) 0 ;
36877 int *arg3 = (int *) 0 ;
36878 void *argp1 = 0 ;
36879 int res1 = 0 ;
36880 int temp2 ;
36881 int res2 = 0 ;
36882 int temp3 ;
36883 int res3 = 0 ;
36884 PyObject * obj0 = 0 ;
36885 PyObject * obj1 = 0 ;
36886 PyObject * obj2 = 0 ;
36887 char * kwnames[] = {
36888 (char *) "self",(char *) "x",(char *) "y", NULL
36889 };
36890
36891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36893 if (!SWIG_IsOK(res1)) {
36894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36895 }
36896 arg1 = reinterpret_cast< wxWindow * >(argp1);
36897 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36898 int val;
36899 int ecode = SWIG_AsVal_int(obj1, &val);
36900 if (!SWIG_IsOK(ecode)) {
36901 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36902 }
36903 temp2 = static_cast< int >(val);
36904 arg2 = &temp2;
36905 res2 = SWIG_AddTmpMask(ecode);
36906 }
36907 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36908 int val;
36909 int ecode = SWIG_AsVal_int(obj2, &val);
36910 if (!SWIG_IsOK(ecode)) {
36911 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36912 }
36913 temp3 = static_cast< int >(val);
36914 arg3 = &temp3;
36915 res3 = SWIG_AddTmpMask(ecode);
36916 }
36917 {
36918 PyThreadState* __tstate = wxPyBeginAllowThreads();
36919 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36920 wxPyEndAllowThreads(__tstate);
36921 if (PyErr_Occurred()) SWIG_fail;
36922 }
36923 resultobj = SWIG_Py_Void();
36924 if (SWIG_IsTmpObj(res2)) {
36925 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36926 } else {
36927 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36928 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36929 }
36930 if (SWIG_IsTmpObj(res3)) {
36931 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36932 } else {
36933 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36934 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36935 }
36936 return resultobj;
36937 fail:
36938 return NULL;
36939 }
36940
36941
36942 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36943 PyObject *resultobj = 0;
36944 wxWindow *arg1 = (wxWindow *) 0 ;
36945 int *arg2 = (int *) 0 ;
36946 int *arg3 = (int *) 0 ;
36947 void *argp1 = 0 ;
36948 int res1 = 0 ;
36949 int temp2 ;
36950 int res2 = 0 ;
36951 int temp3 ;
36952 int res3 = 0 ;
36953 PyObject * obj0 = 0 ;
36954 PyObject * obj1 = 0 ;
36955 PyObject * obj2 = 0 ;
36956 char * kwnames[] = {
36957 (char *) "self",(char *) "x",(char *) "y", NULL
36958 };
36959
36960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36962 if (!SWIG_IsOK(res1)) {
36963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36964 }
36965 arg1 = reinterpret_cast< wxWindow * >(argp1);
36966 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36967 int val;
36968 int ecode = SWIG_AsVal_int(obj1, &val);
36969 if (!SWIG_IsOK(ecode)) {
36970 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36971 }
36972 temp2 = static_cast< int >(val);
36973 arg2 = &temp2;
36974 res2 = SWIG_AddTmpMask(ecode);
36975 }
36976 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36977 int val;
36978 int ecode = SWIG_AsVal_int(obj2, &val);
36979 if (!SWIG_IsOK(ecode)) {
36980 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36981 }
36982 temp3 = static_cast< int >(val);
36983 arg3 = &temp3;
36984 res3 = SWIG_AddTmpMask(ecode);
36985 }
36986 {
36987 PyThreadState* __tstate = wxPyBeginAllowThreads();
36988 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36989 wxPyEndAllowThreads(__tstate);
36990 if (PyErr_Occurred()) SWIG_fail;
36991 }
36992 resultobj = SWIG_Py_Void();
36993 if (SWIG_IsTmpObj(res2)) {
36994 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36995 } else {
36996 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36997 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36998 }
36999 if (SWIG_IsTmpObj(res3)) {
37000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
37001 } else {
37002 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
37003 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
37004 }
37005 return resultobj;
37006 fail:
37007 return NULL;
37008 }
37009
37010
37011 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37012 PyObject *resultobj = 0;
37013 wxWindow *arg1 = (wxWindow *) 0 ;
37014 wxPoint *arg2 = 0 ;
37015 wxPoint result;
37016 void *argp1 = 0 ;
37017 int res1 = 0 ;
37018 wxPoint temp2 ;
37019 PyObject * obj0 = 0 ;
37020 PyObject * obj1 = 0 ;
37021 char * kwnames[] = {
37022 (char *) "self",(char *) "pt", NULL
37023 };
37024
37025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
37026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37027 if (!SWIG_IsOK(res1)) {
37028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37029 }
37030 arg1 = reinterpret_cast< wxWindow * >(argp1);
37031 {
37032 arg2 = &temp2;
37033 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37034 }
37035 {
37036 PyThreadState* __tstate = wxPyBeginAllowThreads();
37037 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
37038 wxPyEndAllowThreads(__tstate);
37039 if (PyErr_Occurred()) SWIG_fail;
37040 }
37041 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37042 return resultobj;
37043 fail:
37044 return NULL;
37045 }
37046
37047
37048 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37049 PyObject *resultobj = 0;
37050 wxWindow *arg1 = (wxWindow *) 0 ;
37051 wxPoint *arg2 = 0 ;
37052 wxPoint result;
37053 void *argp1 = 0 ;
37054 int res1 = 0 ;
37055 wxPoint temp2 ;
37056 PyObject * obj0 = 0 ;
37057 PyObject * obj1 = 0 ;
37058 char * kwnames[] = {
37059 (char *) "self",(char *) "pt", NULL
37060 };
37061
37062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
37063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37064 if (!SWIG_IsOK(res1)) {
37065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
37066 }
37067 arg1 = reinterpret_cast< wxWindow * >(argp1);
37068 {
37069 arg2 = &temp2;
37070 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37071 }
37072 {
37073 PyThreadState* __tstate = wxPyBeginAllowThreads();
37074 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
37075 wxPyEndAllowThreads(__tstate);
37076 if (PyErr_Occurred()) SWIG_fail;
37077 }
37078 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37079 return resultobj;
37080 fail:
37081 return NULL;
37082 }
37083
37084
37085 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37086 PyObject *resultobj = 0;
37087 wxWindow *arg1 = (wxWindow *) 0 ;
37088 int arg2 ;
37089 int arg3 ;
37090 wxHitTest result;
37091 void *argp1 = 0 ;
37092 int res1 = 0 ;
37093 int val2 ;
37094 int ecode2 = 0 ;
37095 int val3 ;
37096 int ecode3 = 0 ;
37097 PyObject * obj0 = 0 ;
37098 PyObject * obj1 = 0 ;
37099 PyObject * obj2 = 0 ;
37100 char * kwnames[] = {
37101 (char *) "self",(char *) "x",(char *) "y", NULL
37102 };
37103
37104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37106 if (!SWIG_IsOK(res1)) {
37107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
37108 }
37109 arg1 = reinterpret_cast< wxWindow * >(argp1);
37110 ecode2 = SWIG_AsVal_int(obj1, &val2);
37111 if (!SWIG_IsOK(ecode2)) {
37112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
37113 }
37114 arg2 = static_cast< int >(val2);
37115 ecode3 = SWIG_AsVal_int(obj2, &val3);
37116 if (!SWIG_IsOK(ecode3)) {
37117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
37118 }
37119 arg3 = static_cast< int >(val3);
37120 {
37121 PyThreadState* __tstate = wxPyBeginAllowThreads();
37122 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
37123 wxPyEndAllowThreads(__tstate);
37124 if (PyErr_Occurred()) SWIG_fail;
37125 }
37126 resultobj = SWIG_From_int(static_cast< int >(result));
37127 return resultobj;
37128 fail:
37129 return NULL;
37130 }
37131
37132
37133 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37134 PyObject *resultobj = 0;
37135 wxWindow *arg1 = (wxWindow *) 0 ;
37136 wxPoint *arg2 = 0 ;
37137 wxHitTest result;
37138 void *argp1 = 0 ;
37139 int res1 = 0 ;
37140 wxPoint temp2 ;
37141 PyObject * obj0 = 0 ;
37142 PyObject * obj1 = 0 ;
37143 char * kwnames[] = {
37144 (char *) "self",(char *) "pt", NULL
37145 };
37146
37147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
37148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37149 if (!SWIG_IsOK(res1)) {
37150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
37151 }
37152 arg1 = reinterpret_cast< wxWindow * >(argp1);
37153 {
37154 arg2 = &temp2;
37155 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37156 }
37157 {
37158 PyThreadState* __tstate = wxPyBeginAllowThreads();
37159 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
37160 wxPyEndAllowThreads(__tstate);
37161 if (PyErr_Occurred()) SWIG_fail;
37162 }
37163 resultobj = SWIG_From_int(static_cast< int >(result));
37164 return resultobj;
37165 fail:
37166 return NULL;
37167 }
37168
37169
37170 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37171 PyObject *resultobj = 0;
37172 wxWindow *arg1 = (wxWindow *) 0 ;
37173 long arg2 ;
37174 wxBorder result;
37175 void *argp1 = 0 ;
37176 int res1 = 0 ;
37177 long val2 ;
37178 int ecode2 = 0 ;
37179
37180 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
37181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37182 if (!SWIG_IsOK(res1)) {
37183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37184 }
37185 arg1 = reinterpret_cast< wxWindow * >(argp1);
37186 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
37187 if (!SWIG_IsOK(ecode2)) {
37188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
37189 }
37190 arg2 = static_cast< long >(val2);
37191 {
37192 PyThreadState* __tstate = wxPyBeginAllowThreads();
37193 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
37194 wxPyEndAllowThreads(__tstate);
37195 if (PyErr_Occurred()) SWIG_fail;
37196 }
37197 resultobj = SWIG_From_int(static_cast< int >(result));
37198 return resultobj;
37199 fail:
37200 return NULL;
37201 }
37202
37203
37204 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37205 PyObject *resultobj = 0;
37206 wxWindow *arg1 = (wxWindow *) 0 ;
37207 wxBorder result;
37208 void *argp1 = 0 ;
37209 int res1 = 0 ;
37210
37211 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
37212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37213 if (!SWIG_IsOK(res1)) {
37214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37215 }
37216 arg1 = reinterpret_cast< wxWindow * >(argp1);
37217 {
37218 PyThreadState* __tstate = wxPyBeginAllowThreads();
37219 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
37220 wxPyEndAllowThreads(__tstate);
37221 if (PyErr_Occurred()) SWIG_fail;
37222 }
37223 resultobj = SWIG_From_int(static_cast< int >(result));
37224 return resultobj;
37225 fail:
37226 return NULL;
37227 }
37228
37229
37230 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
37231 int argc;
37232 PyObject *argv[3];
37233
37234 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
37235 --argc;
37236 if (argc == 1) {
37237 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
37238 }
37239 if (argc == 2) {
37240 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
37241 }
37242
37243 fail:
37244 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
37245 return NULL;
37246 }
37247
37248
37249 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37250 PyObject *resultobj = 0;
37251 wxWindow *arg1 = (wxWindow *) 0 ;
37252 long arg2 = (long) wxUPDATE_UI_NONE ;
37253 void *argp1 = 0 ;
37254 int res1 = 0 ;
37255 long val2 ;
37256 int ecode2 = 0 ;
37257 PyObject * obj0 = 0 ;
37258 PyObject * obj1 = 0 ;
37259 char * kwnames[] = {
37260 (char *) "self",(char *) "flags", NULL
37261 };
37262
37263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
37264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37265 if (!SWIG_IsOK(res1)) {
37266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
37267 }
37268 arg1 = reinterpret_cast< wxWindow * >(argp1);
37269 if (obj1) {
37270 ecode2 = SWIG_AsVal_long(obj1, &val2);
37271 if (!SWIG_IsOK(ecode2)) {
37272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
37273 }
37274 arg2 = static_cast< long >(val2);
37275 }
37276 {
37277 PyThreadState* __tstate = wxPyBeginAllowThreads();
37278 (arg1)->UpdateWindowUI(arg2);
37279 wxPyEndAllowThreads(__tstate);
37280 if (PyErr_Occurred()) SWIG_fail;
37281 }
37282 resultobj = SWIG_Py_Void();
37283 return resultobj;
37284 fail:
37285 return NULL;
37286 }
37287
37288
37289 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37290 PyObject *resultobj = 0;
37291 wxWindow *arg1 = (wxWindow *) 0 ;
37292 wxMenu *arg2 = (wxMenu *) 0 ;
37293 int arg3 = (int) -1 ;
37294 int arg4 = (int) -1 ;
37295 bool result;
37296 void *argp1 = 0 ;
37297 int res1 = 0 ;
37298 void *argp2 = 0 ;
37299 int res2 = 0 ;
37300 int val3 ;
37301 int ecode3 = 0 ;
37302 int val4 ;
37303 int ecode4 = 0 ;
37304 PyObject * obj0 = 0 ;
37305 PyObject * obj1 = 0 ;
37306 PyObject * obj2 = 0 ;
37307 PyObject * obj3 = 0 ;
37308 char * kwnames[] = {
37309 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
37310 };
37311
37312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37314 if (!SWIG_IsOK(res1)) {
37315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
37316 }
37317 arg1 = reinterpret_cast< wxWindow * >(argp1);
37318 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37319 if (!SWIG_IsOK(res2)) {
37320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
37321 }
37322 arg2 = reinterpret_cast< wxMenu * >(argp2);
37323 if (obj2) {
37324 ecode3 = SWIG_AsVal_int(obj2, &val3);
37325 if (!SWIG_IsOK(ecode3)) {
37326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
37327 }
37328 arg3 = static_cast< int >(val3);
37329 }
37330 if (obj3) {
37331 ecode4 = SWIG_AsVal_int(obj3, &val4);
37332 if (!SWIG_IsOK(ecode4)) {
37333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
37334 }
37335 arg4 = static_cast< int >(val4);
37336 }
37337 {
37338 PyThreadState* __tstate = wxPyBeginAllowThreads();
37339 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
37340 wxPyEndAllowThreads(__tstate);
37341 if (PyErr_Occurred()) SWIG_fail;
37342 }
37343 {
37344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37345 }
37346 return resultobj;
37347 fail:
37348 return NULL;
37349 }
37350
37351
37352 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37353 PyObject *resultobj = 0;
37354 wxWindow *arg1 = (wxWindow *) 0 ;
37355 wxMenu *arg2 = (wxMenu *) 0 ;
37356 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37357 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37358 bool result;
37359 void *argp1 = 0 ;
37360 int res1 = 0 ;
37361 void *argp2 = 0 ;
37362 int res2 = 0 ;
37363 wxPoint temp3 ;
37364 PyObject * obj0 = 0 ;
37365 PyObject * obj1 = 0 ;
37366 PyObject * obj2 = 0 ;
37367 char * kwnames[] = {
37368 (char *) "self",(char *) "menu",(char *) "pos", NULL
37369 };
37370
37371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) 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_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
37375 }
37376 arg1 = reinterpret_cast< wxWindow * >(argp1);
37377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37378 if (!SWIG_IsOK(res2)) {
37379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
37380 }
37381 arg2 = reinterpret_cast< wxMenu * >(argp2);
37382 if (obj2) {
37383 {
37384 arg3 = &temp3;
37385 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37386 }
37387 }
37388 {
37389 PyThreadState* __tstate = wxPyBeginAllowThreads();
37390 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
37391 wxPyEndAllowThreads(__tstate);
37392 if (PyErr_Occurred()) SWIG_fail;
37393 }
37394 {
37395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37396 }
37397 return resultobj;
37398 fail:
37399 return NULL;
37400 }
37401
37402
37403 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37404 PyObject *resultobj = 0;
37405 wxWindow *arg1 = (wxWindow *) 0 ;
37406 bool result;
37407 void *argp1 = 0 ;
37408 int res1 = 0 ;
37409 PyObject *swig_obj[1] ;
37410
37411 if (!args) SWIG_fail;
37412 swig_obj[0] = args;
37413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37414 if (!SWIG_IsOK(res1)) {
37415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
37416 }
37417 arg1 = reinterpret_cast< wxWindow * >(argp1);
37418 {
37419 PyThreadState* __tstate = wxPyBeginAllowThreads();
37420 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
37421 wxPyEndAllowThreads(__tstate);
37422 if (PyErr_Occurred()) SWIG_fail;
37423 }
37424 {
37425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37426 }
37427 return resultobj;
37428 fail:
37429 return NULL;
37430 }
37431
37432
37433 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37434 PyObject *resultobj = 0;
37435 wxWindow *arg1 = (wxWindow *) 0 ;
37436 long result;
37437 void *argp1 = 0 ;
37438 int res1 = 0 ;
37439 PyObject *swig_obj[1] ;
37440
37441 if (!args) SWIG_fail;
37442 swig_obj[0] = args;
37443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37444 if (!SWIG_IsOK(res1)) {
37445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37446 }
37447 arg1 = reinterpret_cast< wxWindow * >(argp1);
37448 {
37449 PyThreadState* __tstate = wxPyBeginAllowThreads();
37450 result = (long)wxWindow_GetHandle(arg1);
37451 wxPyEndAllowThreads(__tstate);
37452 if (PyErr_Occurred()) SWIG_fail;
37453 }
37454 resultobj = SWIG_From_long(static_cast< long >(result));
37455 return resultobj;
37456 fail:
37457 return NULL;
37458 }
37459
37460
37461 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37462 PyObject *resultobj = 0;
37463 wxWindow *arg1 = (wxWindow *) 0 ;
37464 long arg2 ;
37465 void *argp1 = 0 ;
37466 int res1 = 0 ;
37467 long val2 ;
37468 int ecode2 = 0 ;
37469 PyObject * obj0 = 0 ;
37470 PyObject * obj1 = 0 ;
37471 char * kwnames[] = {
37472 (char *) "self",(char *) "handle", NULL
37473 };
37474
37475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
37476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37477 if (!SWIG_IsOK(res1)) {
37478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37479 }
37480 arg1 = reinterpret_cast< wxWindow * >(argp1);
37481 ecode2 = SWIG_AsVal_long(obj1, &val2);
37482 if (!SWIG_IsOK(ecode2)) {
37483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
37484 }
37485 arg2 = static_cast< long >(val2);
37486 {
37487 PyThreadState* __tstate = wxPyBeginAllowThreads();
37488 wxWindow_AssociateHandle(arg1,arg2);
37489 wxPyEndAllowThreads(__tstate);
37490 if (PyErr_Occurred()) SWIG_fail;
37491 }
37492 resultobj = SWIG_Py_Void();
37493 return resultobj;
37494 fail:
37495 return NULL;
37496 }
37497
37498
37499 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37500 PyObject *resultobj = 0;
37501 wxWindow *arg1 = (wxWindow *) 0 ;
37502 void *argp1 = 0 ;
37503 int res1 = 0 ;
37504 PyObject *swig_obj[1] ;
37505
37506 if (!args) SWIG_fail;
37507 swig_obj[0] = args;
37508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37509 if (!SWIG_IsOK(res1)) {
37510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37511 }
37512 arg1 = reinterpret_cast< wxWindow * >(argp1);
37513 {
37514 PyThreadState* __tstate = wxPyBeginAllowThreads();
37515 (arg1)->DissociateHandle();
37516 wxPyEndAllowThreads(__tstate);
37517 if (PyErr_Occurred()) SWIG_fail;
37518 }
37519 resultobj = SWIG_Py_Void();
37520 return resultobj;
37521 fail:
37522 return NULL;
37523 }
37524
37525
37526 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37527 PyObject *resultobj = 0;
37528 wxWindow *arg1 = (wxWindow *) 0 ;
37529 int arg2 ;
37530 bool result;
37531 void *argp1 = 0 ;
37532 int res1 = 0 ;
37533 int val2 ;
37534 int ecode2 = 0 ;
37535 PyObject * obj0 = 0 ;
37536 PyObject * obj1 = 0 ;
37537 char * kwnames[] = {
37538 (char *) "self",(char *) "orient", NULL
37539 };
37540
37541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
37542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37543 if (!SWIG_IsOK(res1)) {
37544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
37545 }
37546 arg1 = reinterpret_cast< wxWindow * >(argp1);
37547 ecode2 = SWIG_AsVal_int(obj1, &val2);
37548 if (!SWIG_IsOK(ecode2)) {
37549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
37550 }
37551 arg2 = static_cast< int >(val2);
37552 {
37553 PyThreadState* __tstate = wxPyBeginAllowThreads();
37554 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
37555 wxPyEndAllowThreads(__tstate);
37556 if (PyErr_Occurred()) SWIG_fail;
37557 }
37558 {
37559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37560 }
37561 return resultobj;
37562 fail:
37563 return NULL;
37564 }
37565
37566
37567 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37568 PyObject *resultobj = 0;
37569 wxWindow *arg1 = (wxWindow *) 0 ;
37570 int arg2 ;
37571 int arg3 ;
37572 int arg4 ;
37573 int arg5 ;
37574 bool arg6 = (bool) true ;
37575 void *argp1 = 0 ;
37576 int res1 = 0 ;
37577 int val2 ;
37578 int ecode2 = 0 ;
37579 int val3 ;
37580 int ecode3 = 0 ;
37581 int val4 ;
37582 int ecode4 = 0 ;
37583 int val5 ;
37584 int ecode5 = 0 ;
37585 bool val6 ;
37586 int ecode6 = 0 ;
37587 PyObject * obj0 = 0 ;
37588 PyObject * obj1 = 0 ;
37589 PyObject * obj2 = 0 ;
37590 PyObject * obj3 = 0 ;
37591 PyObject * obj4 = 0 ;
37592 PyObject * obj5 = 0 ;
37593 char * kwnames[] = {
37594 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37595 };
37596
37597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37599 if (!SWIG_IsOK(res1)) {
37600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37601 }
37602 arg1 = reinterpret_cast< wxWindow * >(argp1);
37603 ecode2 = SWIG_AsVal_int(obj1, &val2);
37604 if (!SWIG_IsOK(ecode2)) {
37605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37606 }
37607 arg2 = static_cast< int >(val2);
37608 ecode3 = SWIG_AsVal_int(obj2, &val3);
37609 if (!SWIG_IsOK(ecode3)) {
37610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37611 }
37612 arg3 = static_cast< int >(val3);
37613 ecode4 = SWIG_AsVal_int(obj3, &val4);
37614 if (!SWIG_IsOK(ecode4)) {
37615 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37616 }
37617 arg4 = static_cast< int >(val4);
37618 ecode5 = SWIG_AsVal_int(obj4, &val5);
37619 if (!SWIG_IsOK(ecode5)) {
37620 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37621 }
37622 arg5 = static_cast< int >(val5);
37623 if (obj5) {
37624 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37625 if (!SWIG_IsOK(ecode6)) {
37626 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37627 }
37628 arg6 = static_cast< bool >(val6);
37629 }
37630 {
37631 PyThreadState* __tstate = wxPyBeginAllowThreads();
37632 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37633 wxPyEndAllowThreads(__tstate);
37634 if (PyErr_Occurred()) SWIG_fail;
37635 }
37636 resultobj = SWIG_Py_Void();
37637 return resultobj;
37638 fail:
37639 return NULL;
37640 }
37641
37642
37643 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37644 PyObject *resultobj = 0;
37645 wxWindow *arg1 = (wxWindow *) 0 ;
37646 int arg2 ;
37647 int arg3 ;
37648 bool arg4 = (bool) true ;
37649 void *argp1 = 0 ;
37650 int res1 = 0 ;
37651 int val2 ;
37652 int ecode2 = 0 ;
37653 int val3 ;
37654 int ecode3 = 0 ;
37655 bool val4 ;
37656 int ecode4 = 0 ;
37657 PyObject * obj0 = 0 ;
37658 PyObject * obj1 = 0 ;
37659 PyObject * obj2 = 0 ;
37660 PyObject * obj3 = 0 ;
37661 char * kwnames[] = {
37662 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37663 };
37664
37665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37667 if (!SWIG_IsOK(res1)) {
37668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37669 }
37670 arg1 = reinterpret_cast< wxWindow * >(argp1);
37671 ecode2 = SWIG_AsVal_int(obj1, &val2);
37672 if (!SWIG_IsOK(ecode2)) {
37673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37674 }
37675 arg2 = static_cast< int >(val2);
37676 ecode3 = SWIG_AsVal_int(obj2, &val3);
37677 if (!SWIG_IsOK(ecode3)) {
37678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37679 }
37680 arg3 = static_cast< int >(val3);
37681 if (obj3) {
37682 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37683 if (!SWIG_IsOK(ecode4)) {
37684 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37685 }
37686 arg4 = static_cast< bool >(val4);
37687 }
37688 {
37689 PyThreadState* __tstate = wxPyBeginAllowThreads();
37690 (arg1)->SetScrollPos(arg2,arg3,arg4);
37691 wxPyEndAllowThreads(__tstate);
37692 if (PyErr_Occurred()) SWIG_fail;
37693 }
37694 resultobj = SWIG_Py_Void();
37695 return resultobj;
37696 fail:
37697 return NULL;
37698 }
37699
37700
37701 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37702 PyObject *resultobj = 0;
37703 wxWindow *arg1 = (wxWindow *) 0 ;
37704 int arg2 ;
37705 int result;
37706 void *argp1 = 0 ;
37707 int res1 = 0 ;
37708 int val2 ;
37709 int ecode2 = 0 ;
37710 PyObject * obj0 = 0 ;
37711 PyObject * obj1 = 0 ;
37712 char * kwnames[] = {
37713 (char *) "self",(char *) "orientation", NULL
37714 };
37715
37716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37718 if (!SWIG_IsOK(res1)) {
37719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37720 }
37721 arg1 = reinterpret_cast< wxWindow * >(argp1);
37722 ecode2 = SWIG_AsVal_int(obj1, &val2);
37723 if (!SWIG_IsOK(ecode2)) {
37724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37725 }
37726 arg2 = static_cast< int >(val2);
37727 {
37728 PyThreadState* __tstate = wxPyBeginAllowThreads();
37729 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37730 wxPyEndAllowThreads(__tstate);
37731 if (PyErr_Occurred()) SWIG_fail;
37732 }
37733 resultobj = SWIG_From_int(static_cast< int >(result));
37734 return resultobj;
37735 fail:
37736 return NULL;
37737 }
37738
37739
37740 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37741 PyObject *resultobj = 0;
37742 wxWindow *arg1 = (wxWindow *) 0 ;
37743 int arg2 ;
37744 int result;
37745 void *argp1 = 0 ;
37746 int res1 = 0 ;
37747 int val2 ;
37748 int ecode2 = 0 ;
37749 PyObject * obj0 = 0 ;
37750 PyObject * obj1 = 0 ;
37751 char * kwnames[] = {
37752 (char *) "self",(char *) "orientation", NULL
37753 };
37754
37755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37757 if (!SWIG_IsOK(res1)) {
37758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37759 }
37760 arg1 = reinterpret_cast< wxWindow * >(argp1);
37761 ecode2 = SWIG_AsVal_int(obj1, &val2);
37762 if (!SWIG_IsOK(ecode2)) {
37763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37764 }
37765 arg2 = static_cast< int >(val2);
37766 {
37767 PyThreadState* __tstate = wxPyBeginAllowThreads();
37768 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37769 wxPyEndAllowThreads(__tstate);
37770 if (PyErr_Occurred()) SWIG_fail;
37771 }
37772 resultobj = SWIG_From_int(static_cast< int >(result));
37773 return resultobj;
37774 fail:
37775 return NULL;
37776 }
37777
37778
37779 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37780 PyObject *resultobj = 0;
37781 wxWindow *arg1 = (wxWindow *) 0 ;
37782 int arg2 ;
37783 int result;
37784 void *argp1 = 0 ;
37785 int res1 = 0 ;
37786 int val2 ;
37787 int ecode2 = 0 ;
37788 PyObject * obj0 = 0 ;
37789 PyObject * obj1 = 0 ;
37790 char * kwnames[] = {
37791 (char *) "self",(char *) "orientation", NULL
37792 };
37793
37794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37796 if (!SWIG_IsOK(res1)) {
37797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37798 }
37799 arg1 = reinterpret_cast< wxWindow * >(argp1);
37800 ecode2 = SWIG_AsVal_int(obj1, &val2);
37801 if (!SWIG_IsOK(ecode2)) {
37802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37803 }
37804 arg2 = static_cast< int >(val2);
37805 {
37806 PyThreadState* __tstate = wxPyBeginAllowThreads();
37807 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37808 wxPyEndAllowThreads(__tstate);
37809 if (PyErr_Occurred()) SWIG_fail;
37810 }
37811 resultobj = SWIG_From_int(static_cast< int >(result));
37812 return resultobj;
37813 fail:
37814 return NULL;
37815 }
37816
37817
37818 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37819 PyObject *resultobj = 0;
37820 wxWindow *arg1 = (wxWindow *) 0 ;
37821 int arg2 ;
37822 int arg3 ;
37823 wxRect *arg4 = (wxRect *) NULL ;
37824 void *argp1 = 0 ;
37825 int res1 = 0 ;
37826 int val2 ;
37827 int ecode2 = 0 ;
37828 int val3 ;
37829 int ecode3 = 0 ;
37830 void *argp4 = 0 ;
37831 int res4 = 0 ;
37832 PyObject * obj0 = 0 ;
37833 PyObject * obj1 = 0 ;
37834 PyObject * obj2 = 0 ;
37835 PyObject * obj3 = 0 ;
37836 char * kwnames[] = {
37837 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37838 };
37839
37840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37842 if (!SWIG_IsOK(res1)) {
37843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37844 }
37845 arg1 = reinterpret_cast< wxWindow * >(argp1);
37846 ecode2 = SWIG_AsVal_int(obj1, &val2);
37847 if (!SWIG_IsOK(ecode2)) {
37848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37849 }
37850 arg2 = static_cast< int >(val2);
37851 ecode3 = SWIG_AsVal_int(obj2, &val3);
37852 if (!SWIG_IsOK(ecode3)) {
37853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37854 }
37855 arg3 = static_cast< int >(val3);
37856 if (obj3) {
37857 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37858 if (!SWIG_IsOK(res4)) {
37859 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37860 }
37861 arg4 = reinterpret_cast< wxRect * >(argp4);
37862 }
37863 {
37864 PyThreadState* __tstate = wxPyBeginAllowThreads();
37865 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37866 wxPyEndAllowThreads(__tstate);
37867 if (PyErr_Occurred()) SWIG_fail;
37868 }
37869 resultobj = SWIG_Py_Void();
37870 return resultobj;
37871 fail:
37872 return NULL;
37873 }
37874
37875
37876 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37877 PyObject *resultobj = 0;
37878 wxWindow *arg1 = (wxWindow *) 0 ;
37879 int arg2 ;
37880 bool result;
37881 void *argp1 = 0 ;
37882 int res1 = 0 ;
37883 int val2 ;
37884 int ecode2 = 0 ;
37885 PyObject * obj0 = 0 ;
37886 PyObject * obj1 = 0 ;
37887 char * kwnames[] = {
37888 (char *) "self",(char *) "lines", NULL
37889 };
37890
37891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37893 if (!SWIG_IsOK(res1)) {
37894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37895 }
37896 arg1 = reinterpret_cast< wxWindow * >(argp1);
37897 ecode2 = SWIG_AsVal_int(obj1, &val2);
37898 if (!SWIG_IsOK(ecode2)) {
37899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37900 }
37901 arg2 = static_cast< int >(val2);
37902 {
37903 PyThreadState* __tstate = wxPyBeginAllowThreads();
37904 result = (bool)(arg1)->ScrollLines(arg2);
37905 wxPyEndAllowThreads(__tstate);
37906 if (PyErr_Occurred()) SWIG_fail;
37907 }
37908 {
37909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37910 }
37911 return resultobj;
37912 fail:
37913 return NULL;
37914 }
37915
37916
37917 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37918 PyObject *resultobj = 0;
37919 wxWindow *arg1 = (wxWindow *) 0 ;
37920 int arg2 ;
37921 bool result;
37922 void *argp1 = 0 ;
37923 int res1 = 0 ;
37924 int val2 ;
37925 int ecode2 = 0 ;
37926 PyObject * obj0 = 0 ;
37927 PyObject * obj1 = 0 ;
37928 char * kwnames[] = {
37929 (char *) "self",(char *) "pages", NULL
37930 };
37931
37932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37934 if (!SWIG_IsOK(res1)) {
37935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37936 }
37937 arg1 = reinterpret_cast< wxWindow * >(argp1);
37938 ecode2 = SWIG_AsVal_int(obj1, &val2);
37939 if (!SWIG_IsOK(ecode2)) {
37940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37941 }
37942 arg2 = static_cast< int >(val2);
37943 {
37944 PyThreadState* __tstate = wxPyBeginAllowThreads();
37945 result = (bool)(arg1)->ScrollPages(arg2);
37946 wxPyEndAllowThreads(__tstate);
37947 if (PyErr_Occurred()) SWIG_fail;
37948 }
37949 {
37950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37951 }
37952 return resultobj;
37953 fail:
37954 return NULL;
37955 }
37956
37957
37958 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37959 PyObject *resultobj = 0;
37960 wxWindow *arg1 = (wxWindow *) 0 ;
37961 bool result;
37962 void *argp1 = 0 ;
37963 int res1 = 0 ;
37964 PyObject *swig_obj[1] ;
37965
37966 if (!args) SWIG_fail;
37967 swig_obj[0] = args;
37968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37969 if (!SWIG_IsOK(res1)) {
37970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37971 }
37972 arg1 = reinterpret_cast< wxWindow * >(argp1);
37973 {
37974 PyThreadState* __tstate = wxPyBeginAllowThreads();
37975 result = (bool)(arg1)->LineUp();
37976 wxPyEndAllowThreads(__tstate);
37977 if (PyErr_Occurred()) SWIG_fail;
37978 }
37979 {
37980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37981 }
37982 return resultobj;
37983 fail:
37984 return NULL;
37985 }
37986
37987
37988 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37989 PyObject *resultobj = 0;
37990 wxWindow *arg1 = (wxWindow *) 0 ;
37991 bool result;
37992 void *argp1 = 0 ;
37993 int res1 = 0 ;
37994 PyObject *swig_obj[1] ;
37995
37996 if (!args) SWIG_fail;
37997 swig_obj[0] = args;
37998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37999 if (!SWIG_IsOK(res1)) {
38000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
38001 }
38002 arg1 = reinterpret_cast< wxWindow * >(argp1);
38003 {
38004 PyThreadState* __tstate = wxPyBeginAllowThreads();
38005 result = (bool)(arg1)->LineDown();
38006 wxPyEndAllowThreads(__tstate);
38007 if (PyErr_Occurred()) SWIG_fail;
38008 }
38009 {
38010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38011 }
38012 return resultobj;
38013 fail:
38014 return NULL;
38015 }
38016
38017
38018 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38019 PyObject *resultobj = 0;
38020 wxWindow *arg1 = (wxWindow *) 0 ;
38021 bool result;
38022 void *argp1 = 0 ;
38023 int res1 = 0 ;
38024 PyObject *swig_obj[1] ;
38025
38026 if (!args) SWIG_fail;
38027 swig_obj[0] = args;
38028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38029 if (!SWIG_IsOK(res1)) {
38030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
38031 }
38032 arg1 = reinterpret_cast< wxWindow * >(argp1);
38033 {
38034 PyThreadState* __tstate = wxPyBeginAllowThreads();
38035 result = (bool)(arg1)->PageUp();
38036 wxPyEndAllowThreads(__tstate);
38037 if (PyErr_Occurred()) SWIG_fail;
38038 }
38039 {
38040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38041 }
38042 return resultobj;
38043 fail:
38044 return NULL;
38045 }
38046
38047
38048 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38049 PyObject *resultobj = 0;
38050 wxWindow *arg1 = (wxWindow *) 0 ;
38051 bool result;
38052 void *argp1 = 0 ;
38053 int res1 = 0 ;
38054 PyObject *swig_obj[1] ;
38055
38056 if (!args) SWIG_fail;
38057 swig_obj[0] = args;
38058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38059 if (!SWIG_IsOK(res1)) {
38060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
38061 }
38062 arg1 = reinterpret_cast< wxWindow * >(argp1);
38063 {
38064 PyThreadState* __tstate = wxPyBeginAllowThreads();
38065 result = (bool)(arg1)->PageDown();
38066 wxPyEndAllowThreads(__tstate);
38067 if (PyErr_Occurred()) SWIG_fail;
38068 }
38069 {
38070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38071 }
38072 return resultobj;
38073 fail:
38074 return NULL;
38075 }
38076
38077
38078 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38079 PyObject *resultobj = 0;
38080 wxWindow *arg1 = (wxWindow *) 0 ;
38081 wxString *arg2 = 0 ;
38082 void *argp1 = 0 ;
38083 int res1 = 0 ;
38084 bool temp2 = false ;
38085 PyObject * obj0 = 0 ;
38086 PyObject * obj1 = 0 ;
38087 char * kwnames[] = {
38088 (char *) "self",(char *) "text", NULL
38089 };
38090
38091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
38092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38093 if (!SWIG_IsOK(res1)) {
38094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
38095 }
38096 arg1 = reinterpret_cast< wxWindow * >(argp1);
38097 {
38098 arg2 = wxString_in_helper(obj1);
38099 if (arg2 == NULL) SWIG_fail;
38100 temp2 = true;
38101 }
38102 {
38103 PyThreadState* __tstate = wxPyBeginAllowThreads();
38104 (arg1)->SetHelpText((wxString const &)*arg2);
38105 wxPyEndAllowThreads(__tstate);
38106 if (PyErr_Occurred()) SWIG_fail;
38107 }
38108 resultobj = SWIG_Py_Void();
38109 {
38110 if (temp2)
38111 delete arg2;
38112 }
38113 return resultobj;
38114 fail:
38115 {
38116 if (temp2)
38117 delete arg2;
38118 }
38119 return NULL;
38120 }
38121
38122
38123 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38124 PyObject *resultobj = 0;
38125 wxWindow *arg1 = (wxWindow *) 0 ;
38126 wxString *arg2 = 0 ;
38127 void *argp1 = 0 ;
38128 int res1 = 0 ;
38129 bool temp2 = false ;
38130 PyObject * obj0 = 0 ;
38131 PyObject * obj1 = 0 ;
38132 char * kwnames[] = {
38133 (char *) "self",(char *) "text", NULL
38134 };
38135
38136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
38137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38138 if (!SWIG_IsOK(res1)) {
38139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
38140 }
38141 arg1 = reinterpret_cast< wxWindow * >(argp1);
38142 {
38143 arg2 = wxString_in_helper(obj1);
38144 if (arg2 == NULL) SWIG_fail;
38145 temp2 = true;
38146 }
38147 {
38148 PyThreadState* __tstate = wxPyBeginAllowThreads();
38149 (arg1)->SetHelpTextForId((wxString const &)*arg2);
38150 wxPyEndAllowThreads(__tstate);
38151 if (PyErr_Occurred()) SWIG_fail;
38152 }
38153 resultobj = SWIG_Py_Void();
38154 {
38155 if (temp2)
38156 delete arg2;
38157 }
38158 return resultobj;
38159 fail:
38160 {
38161 if (temp2)
38162 delete arg2;
38163 }
38164 return NULL;
38165 }
38166
38167
38168 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38169 PyObject *resultobj = 0;
38170 wxWindow *arg1 = (wxWindow *) 0 ;
38171 wxPoint *arg2 = 0 ;
38172 wxHelpEvent::Origin arg3 ;
38173 wxString result;
38174 void *argp1 = 0 ;
38175 int res1 = 0 ;
38176 wxPoint temp2 ;
38177 void *argp3 ;
38178 int res3 = 0 ;
38179 PyObject * obj0 = 0 ;
38180 PyObject * obj1 = 0 ;
38181 PyObject * obj2 = 0 ;
38182 char * kwnames[] = {
38183 (char *) "self",(char *) "pt",(char *) "origin", NULL
38184 };
38185
38186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38188 if (!SWIG_IsOK(res1)) {
38189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38190 }
38191 arg1 = reinterpret_cast< wxWindow * >(argp1);
38192 {
38193 arg2 = &temp2;
38194 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38195 }
38196 {
38197 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
38198 if (!SWIG_IsOK(res3)) {
38199 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38200 }
38201 if (!argp3) {
38202 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38203 } else {
38204 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
38205 arg3 = *temp;
38206 if (SWIG_IsNewObj(res3)) delete temp;
38207 }
38208 }
38209 {
38210 PyThreadState* __tstate = wxPyBeginAllowThreads();
38211 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
38212 wxPyEndAllowThreads(__tstate);
38213 if (PyErr_Occurred()) SWIG_fail;
38214 }
38215 {
38216 #if wxUSE_UNICODE
38217 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38218 #else
38219 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38220 #endif
38221 }
38222 return resultobj;
38223 fail:
38224 return NULL;
38225 }
38226
38227
38228 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38229 PyObject *resultobj = 0;
38230 wxWindow *arg1 = (wxWindow *) 0 ;
38231 wxString result;
38232 void *argp1 = 0 ;
38233 int res1 = 0 ;
38234 PyObject *swig_obj[1] ;
38235
38236 if (!args) SWIG_fail;
38237 swig_obj[0] = args;
38238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38239 if (!SWIG_IsOK(res1)) {
38240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
38241 }
38242 arg1 = reinterpret_cast< wxWindow * >(argp1);
38243 {
38244 PyThreadState* __tstate = wxPyBeginAllowThreads();
38245 result = ((wxWindow const *)arg1)->GetHelpText();
38246 wxPyEndAllowThreads(__tstate);
38247 if (PyErr_Occurred()) SWIG_fail;
38248 }
38249 {
38250 #if wxUSE_UNICODE
38251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38252 #else
38253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38254 #endif
38255 }
38256 return resultobj;
38257 fail:
38258 return NULL;
38259 }
38260
38261
38262 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38263 PyObject *resultobj = 0;
38264 wxWindow *arg1 = (wxWindow *) 0 ;
38265 wxString *arg2 = 0 ;
38266 void *argp1 = 0 ;
38267 int res1 = 0 ;
38268 bool temp2 = false ;
38269 PyObject * obj0 = 0 ;
38270 PyObject * obj1 = 0 ;
38271 char * kwnames[] = {
38272 (char *) "self",(char *) "tip", NULL
38273 };
38274
38275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
38276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38277 if (!SWIG_IsOK(res1)) {
38278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
38279 }
38280 arg1 = reinterpret_cast< wxWindow * >(argp1);
38281 {
38282 arg2 = wxString_in_helper(obj1);
38283 if (arg2 == NULL) SWIG_fail;
38284 temp2 = true;
38285 }
38286 {
38287 PyThreadState* __tstate = wxPyBeginAllowThreads();
38288 (arg1)->SetToolTip((wxString const &)*arg2);
38289 wxPyEndAllowThreads(__tstate);
38290 if (PyErr_Occurred()) SWIG_fail;
38291 }
38292 resultobj = SWIG_Py_Void();
38293 {
38294 if (temp2)
38295 delete arg2;
38296 }
38297 return resultobj;
38298 fail:
38299 {
38300 if (temp2)
38301 delete arg2;
38302 }
38303 return NULL;
38304 }
38305
38306
38307 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38308 PyObject *resultobj = 0;
38309 wxWindow *arg1 = (wxWindow *) 0 ;
38310 wxToolTip *arg2 = (wxToolTip *) 0 ;
38311 void *argp1 = 0 ;
38312 int res1 = 0 ;
38313 int res2 = 0 ;
38314 PyObject * obj0 = 0 ;
38315 PyObject * obj1 = 0 ;
38316 char * kwnames[] = {
38317 (char *) "self",(char *) "tip", NULL
38318 };
38319
38320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
38321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38322 if (!SWIG_IsOK(res1)) {
38323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
38324 }
38325 arg1 = reinterpret_cast< wxWindow * >(argp1);
38326 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
38327 if (!SWIG_IsOK(res2)) {
38328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
38329 }
38330 {
38331 PyThreadState* __tstate = wxPyBeginAllowThreads();
38332 (arg1)->SetToolTip(arg2);
38333 wxPyEndAllowThreads(__tstate);
38334 if (PyErr_Occurred()) SWIG_fail;
38335 }
38336 resultobj = SWIG_Py_Void();
38337 return resultobj;
38338 fail:
38339 return NULL;
38340 }
38341
38342
38343 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38344 PyObject *resultobj = 0;
38345 wxWindow *arg1 = (wxWindow *) 0 ;
38346 wxToolTip *result = 0 ;
38347 void *argp1 = 0 ;
38348 int res1 = 0 ;
38349 PyObject *swig_obj[1] ;
38350
38351 if (!args) SWIG_fail;
38352 swig_obj[0] = args;
38353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38354 if (!SWIG_IsOK(res1)) {
38355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
38356 }
38357 arg1 = reinterpret_cast< wxWindow * >(argp1);
38358 {
38359 PyThreadState* __tstate = wxPyBeginAllowThreads();
38360 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
38361 wxPyEndAllowThreads(__tstate);
38362 if (PyErr_Occurred()) SWIG_fail;
38363 }
38364 {
38365 resultobj = wxPyMake_wxObject(result, (bool)0);
38366 }
38367 return resultobj;
38368 fail:
38369 return NULL;
38370 }
38371
38372
38373 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38374 PyObject *resultobj = 0;
38375 wxWindow *arg1 = (wxWindow *) 0 ;
38376 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
38377 void *argp1 = 0 ;
38378 int res1 = 0 ;
38379 int res2 = 0 ;
38380 PyObject * obj0 = 0 ;
38381 PyObject * obj1 = 0 ;
38382 char * kwnames[] = {
38383 (char *) "self",(char *) "dropTarget", NULL
38384 };
38385
38386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
38387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38388 if (!SWIG_IsOK(res1)) {
38389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
38390 }
38391 arg1 = reinterpret_cast< wxWindow * >(argp1);
38392 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
38393 if (!SWIG_IsOK(res2)) {
38394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
38395 }
38396 {
38397 PyThreadState* __tstate = wxPyBeginAllowThreads();
38398 (arg1)->SetDropTarget(arg2);
38399 wxPyEndAllowThreads(__tstate);
38400 if (PyErr_Occurred()) SWIG_fail;
38401 }
38402 resultobj = SWIG_Py_Void();
38403 return resultobj;
38404 fail:
38405 return NULL;
38406 }
38407
38408
38409 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38410 PyObject *resultobj = 0;
38411 wxWindow *arg1 = (wxWindow *) 0 ;
38412 wxPyDropTarget *result = 0 ;
38413 void *argp1 = 0 ;
38414 int res1 = 0 ;
38415 PyObject *swig_obj[1] ;
38416
38417 if (!args) SWIG_fail;
38418 swig_obj[0] = args;
38419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38420 if (!SWIG_IsOK(res1)) {
38421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
38422 }
38423 arg1 = reinterpret_cast< wxWindow * >(argp1);
38424 {
38425 PyThreadState* __tstate = wxPyBeginAllowThreads();
38426 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
38427 wxPyEndAllowThreads(__tstate);
38428 if (PyErr_Occurred()) SWIG_fail;
38429 }
38430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
38431 return resultobj;
38432 fail:
38433 return NULL;
38434 }
38435
38436
38437 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38438 PyObject *resultobj = 0;
38439 wxWindow *arg1 = (wxWindow *) 0 ;
38440 bool arg2 ;
38441 void *argp1 = 0 ;
38442 int res1 = 0 ;
38443 bool val2 ;
38444 int ecode2 = 0 ;
38445 PyObject * obj0 = 0 ;
38446 PyObject * obj1 = 0 ;
38447 char * kwnames[] = {
38448 (char *) "self",(char *) "accept", NULL
38449 };
38450
38451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
38452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38453 if (!SWIG_IsOK(res1)) {
38454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
38455 }
38456 arg1 = reinterpret_cast< wxWindow * >(argp1);
38457 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38458 if (!SWIG_IsOK(ecode2)) {
38459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
38460 }
38461 arg2 = static_cast< bool >(val2);
38462 {
38463 PyThreadState* __tstate = wxPyBeginAllowThreads();
38464 wxWindow_DragAcceptFiles(arg1,arg2);
38465 wxPyEndAllowThreads(__tstate);
38466 if (PyErr_Occurred()) SWIG_fail;
38467 }
38468 resultobj = SWIG_Py_Void();
38469 return resultobj;
38470 fail:
38471 return NULL;
38472 }
38473
38474
38475 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38476 PyObject *resultobj = 0;
38477 wxWindow *arg1 = (wxWindow *) 0 ;
38478 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
38479 void *argp1 = 0 ;
38480 int res1 = 0 ;
38481 int res2 = 0 ;
38482 PyObject * obj0 = 0 ;
38483 PyObject * obj1 = 0 ;
38484 char * kwnames[] = {
38485 (char *) "self",(char *) "constraints", NULL
38486 };
38487
38488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
38489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38490 if (!SWIG_IsOK(res1)) {
38491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
38492 }
38493 arg1 = reinterpret_cast< wxWindow * >(argp1);
38494 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
38495 if (!SWIG_IsOK(res2)) {
38496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
38497 }
38498 {
38499 PyThreadState* __tstate = wxPyBeginAllowThreads();
38500 (arg1)->SetConstraints(arg2);
38501 wxPyEndAllowThreads(__tstate);
38502 if (PyErr_Occurred()) SWIG_fail;
38503 }
38504 resultobj = SWIG_Py_Void();
38505 return resultobj;
38506 fail:
38507 return NULL;
38508 }
38509
38510
38511 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38512 PyObject *resultobj = 0;
38513 wxWindow *arg1 = (wxWindow *) 0 ;
38514 wxLayoutConstraints *result = 0 ;
38515 void *argp1 = 0 ;
38516 int res1 = 0 ;
38517 PyObject *swig_obj[1] ;
38518
38519 if (!args) SWIG_fail;
38520 swig_obj[0] = args;
38521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38522 if (!SWIG_IsOK(res1)) {
38523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
38524 }
38525 arg1 = reinterpret_cast< wxWindow * >(argp1);
38526 {
38527 PyThreadState* __tstate = wxPyBeginAllowThreads();
38528 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
38529 wxPyEndAllowThreads(__tstate);
38530 if (PyErr_Occurred()) SWIG_fail;
38531 }
38532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
38533 return resultobj;
38534 fail:
38535 return NULL;
38536 }
38537
38538
38539 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38540 PyObject *resultobj = 0;
38541 wxWindow *arg1 = (wxWindow *) 0 ;
38542 bool arg2 ;
38543 void *argp1 = 0 ;
38544 int res1 = 0 ;
38545 bool val2 ;
38546 int ecode2 = 0 ;
38547 PyObject * obj0 = 0 ;
38548 PyObject * obj1 = 0 ;
38549 char * kwnames[] = {
38550 (char *) "self",(char *) "autoLayout", NULL
38551 };
38552
38553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
38554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38555 if (!SWIG_IsOK(res1)) {
38556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
38557 }
38558 arg1 = reinterpret_cast< wxWindow * >(argp1);
38559 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38560 if (!SWIG_IsOK(ecode2)) {
38561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
38562 }
38563 arg2 = static_cast< bool >(val2);
38564 {
38565 PyThreadState* __tstate = wxPyBeginAllowThreads();
38566 (arg1)->SetAutoLayout(arg2);
38567 wxPyEndAllowThreads(__tstate);
38568 if (PyErr_Occurred()) SWIG_fail;
38569 }
38570 resultobj = SWIG_Py_Void();
38571 return resultobj;
38572 fail:
38573 return NULL;
38574 }
38575
38576
38577 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38578 PyObject *resultobj = 0;
38579 wxWindow *arg1 = (wxWindow *) 0 ;
38580 bool result;
38581 void *argp1 = 0 ;
38582 int res1 = 0 ;
38583 PyObject *swig_obj[1] ;
38584
38585 if (!args) SWIG_fail;
38586 swig_obj[0] = args;
38587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38588 if (!SWIG_IsOK(res1)) {
38589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38590 }
38591 arg1 = reinterpret_cast< wxWindow * >(argp1);
38592 {
38593 PyThreadState* __tstate = wxPyBeginAllowThreads();
38594 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38595 wxPyEndAllowThreads(__tstate);
38596 if (PyErr_Occurred()) SWIG_fail;
38597 }
38598 {
38599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38600 }
38601 return resultobj;
38602 fail:
38603 return NULL;
38604 }
38605
38606
38607 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38608 PyObject *resultobj = 0;
38609 wxWindow *arg1 = (wxWindow *) 0 ;
38610 bool result;
38611 void *argp1 = 0 ;
38612 int res1 = 0 ;
38613 PyObject *swig_obj[1] ;
38614
38615 if (!args) SWIG_fail;
38616 swig_obj[0] = args;
38617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38618 if (!SWIG_IsOK(res1)) {
38619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38620 }
38621 arg1 = reinterpret_cast< wxWindow * >(argp1);
38622 {
38623 PyThreadState* __tstate = wxPyBeginAllowThreads();
38624 result = (bool)(arg1)->Layout();
38625 wxPyEndAllowThreads(__tstate);
38626 if (PyErr_Occurred()) SWIG_fail;
38627 }
38628 {
38629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38630 }
38631 return resultobj;
38632 fail:
38633 return NULL;
38634 }
38635
38636
38637 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38638 PyObject *resultobj = 0;
38639 wxWindow *arg1 = (wxWindow *) 0 ;
38640 wxSizer *arg2 = (wxSizer *) 0 ;
38641 bool arg3 = (bool) true ;
38642 void *argp1 = 0 ;
38643 int res1 = 0 ;
38644 int res2 = 0 ;
38645 bool val3 ;
38646 int ecode3 = 0 ;
38647 PyObject * obj0 = 0 ;
38648 PyObject * obj1 = 0 ;
38649 PyObject * obj2 = 0 ;
38650 char * kwnames[] = {
38651 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38652 };
38653
38654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38656 if (!SWIG_IsOK(res1)) {
38657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38658 }
38659 arg1 = reinterpret_cast< wxWindow * >(argp1);
38660 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38661 if (!SWIG_IsOK(res2)) {
38662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38663 }
38664 if (obj2) {
38665 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38666 if (!SWIG_IsOK(ecode3)) {
38667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38668 }
38669 arg3 = static_cast< bool >(val3);
38670 }
38671 {
38672 PyThreadState* __tstate = wxPyBeginAllowThreads();
38673 (arg1)->SetSizer(arg2,arg3);
38674 wxPyEndAllowThreads(__tstate);
38675 if (PyErr_Occurred()) SWIG_fail;
38676 }
38677 resultobj = SWIG_Py_Void();
38678 return resultobj;
38679 fail:
38680 return NULL;
38681 }
38682
38683
38684 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38685 PyObject *resultobj = 0;
38686 wxWindow *arg1 = (wxWindow *) 0 ;
38687 wxSizer *arg2 = (wxSizer *) 0 ;
38688 bool arg3 = (bool) true ;
38689 void *argp1 = 0 ;
38690 int res1 = 0 ;
38691 int res2 = 0 ;
38692 bool val3 ;
38693 int ecode3 = 0 ;
38694 PyObject * obj0 = 0 ;
38695 PyObject * obj1 = 0 ;
38696 PyObject * obj2 = 0 ;
38697 char * kwnames[] = {
38698 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38699 };
38700
38701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38703 if (!SWIG_IsOK(res1)) {
38704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38705 }
38706 arg1 = reinterpret_cast< wxWindow * >(argp1);
38707 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38708 if (!SWIG_IsOK(res2)) {
38709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38710 }
38711 if (obj2) {
38712 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38713 if (!SWIG_IsOK(ecode3)) {
38714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38715 }
38716 arg3 = static_cast< bool >(val3);
38717 }
38718 {
38719 PyThreadState* __tstate = wxPyBeginAllowThreads();
38720 (arg1)->SetSizerAndFit(arg2,arg3);
38721 wxPyEndAllowThreads(__tstate);
38722 if (PyErr_Occurred()) SWIG_fail;
38723 }
38724 resultobj = SWIG_Py_Void();
38725 return resultobj;
38726 fail:
38727 return NULL;
38728 }
38729
38730
38731 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38732 PyObject *resultobj = 0;
38733 wxWindow *arg1 = (wxWindow *) 0 ;
38734 wxSizer *result = 0 ;
38735 void *argp1 = 0 ;
38736 int res1 = 0 ;
38737 PyObject *swig_obj[1] ;
38738
38739 if (!args) SWIG_fail;
38740 swig_obj[0] = args;
38741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38742 if (!SWIG_IsOK(res1)) {
38743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38744 }
38745 arg1 = reinterpret_cast< wxWindow * >(argp1);
38746 {
38747 PyThreadState* __tstate = wxPyBeginAllowThreads();
38748 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38749 wxPyEndAllowThreads(__tstate);
38750 if (PyErr_Occurred()) SWIG_fail;
38751 }
38752 {
38753 resultobj = wxPyMake_wxObject(result, (bool)0);
38754 }
38755 return resultobj;
38756 fail:
38757 return NULL;
38758 }
38759
38760
38761 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38762 PyObject *resultobj = 0;
38763 wxWindow *arg1 = (wxWindow *) 0 ;
38764 wxSizer *arg2 = (wxSizer *) 0 ;
38765 void *argp1 = 0 ;
38766 int res1 = 0 ;
38767 void *argp2 = 0 ;
38768 int res2 = 0 ;
38769 PyObject * obj0 = 0 ;
38770 PyObject * obj1 = 0 ;
38771 char * kwnames[] = {
38772 (char *) "self",(char *) "sizer", NULL
38773 };
38774
38775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38777 if (!SWIG_IsOK(res1)) {
38778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38779 }
38780 arg1 = reinterpret_cast< wxWindow * >(argp1);
38781 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38782 if (!SWIG_IsOK(res2)) {
38783 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38784 }
38785 arg2 = reinterpret_cast< wxSizer * >(argp2);
38786 {
38787 PyThreadState* __tstate = wxPyBeginAllowThreads();
38788 (arg1)->SetContainingSizer(arg2);
38789 wxPyEndAllowThreads(__tstate);
38790 if (PyErr_Occurred()) SWIG_fail;
38791 }
38792 resultobj = SWIG_Py_Void();
38793 return resultobj;
38794 fail:
38795 return NULL;
38796 }
38797
38798
38799 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38800 PyObject *resultobj = 0;
38801 wxWindow *arg1 = (wxWindow *) 0 ;
38802 wxSizer *result = 0 ;
38803 void *argp1 = 0 ;
38804 int res1 = 0 ;
38805 PyObject *swig_obj[1] ;
38806
38807 if (!args) SWIG_fail;
38808 swig_obj[0] = args;
38809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38810 if (!SWIG_IsOK(res1)) {
38811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38812 }
38813 arg1 = reinterpret_cast< wxWindow * >(argp1);
38814 {
38815 PyThreadState* __tstate = wxPyBeginAllowThreads();
38816 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38817 wxPyEndAllowThreads(__tstate);
38818 if (PyErr_Occurred()) SWIG_fail;
38819 }
38820 {
38821 resultobj = wxPyMake_wxObject(result, (bool)0);
38822 }
38823 return resultobj;
38824 fail:
38825 return NULL;
38826 }
38827
38828
38829 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38830 PyObject *resultobj = 0;
38831 wxWindow *arg1 = (wxWindow *) 0 ;
38832 void *argp1 = 0 ;
38833 int res1 = 0 ;
38834 PyObject *swig_obj[1] ;
38835
38836 if (!args) SWIG_fail;
38837 swig_obj[0] = args;
38838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38839 if (!SWIG_IsOK(res1)) {
38840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38841 }
38842 arg1 = reinterpret_cast< wxWindow * >(argp1);
38843 {
38844 PyThreadState* __tstate = wxPyBeginAllowThreads();
38845 (arg1)->InheritAttributes();
38846 wxPyEndAllowThreads(__tstate);
38847 if (PyErr_Occurred()) SWIG_fail;
38848 }
38849 resultobj = SWIG_Py_Void();
38850 return resultobj;
38851 fail:
38852 return NULL;
38853 }
38854
38855
38856 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38857 PyObject *resultobj = 0;
38858 wxWindow *arg1 = (wxWindow *) 0 ;
38859 bool result;
38860 void *argp1 = 0 ;
38861 int res1 = 0 ;
38862 PyObject *swig_obj[1] ;
38863
38864 if (!args) SWIG_fail;
38865 swig_obj[0] = args;
38866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38867 if (!SWIG_IsOK(res1)) {
38868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38869 }
38870 arg1 = reinterpret_cast< wxWindow * >(argp1);
38871 {
38872 PyThreadState* __tstate = wxPyBeginAllowThreads();
38873 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38874 wxPyEndAllowThreads(__tstate);
38875 if (PyErr_Occurred()) SWIG_fail;
38876 }
38877 {
38878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38879 }
38880 return resultobj;
38881 fail:
38882 return NULL;
38883 }
38884
38885
38886 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38887 PyObject *resultobj = 0;
38888 wxWindow *arg1 = (wxWindow *) 0 ;
38889 bool result;
38890 void *argp1 = 0 ;
38891 int res1 = 0 ;
38892 PyObject *swig_obj[1] ;
38893
38894 if (!args) SWIG_fail;
38895 swig_obj[0] = args;
38896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38897 if (!SWIG_IsOK(res1)) {
38898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38899 }
38900 arg1 = reinterpret_cast< wxWindow * >(argp1);
38901 {
38902 PyThreadState* __tstate = wxPyBeginAllowThreads();
38903 result = (bool)(arg1)->CanSetTransparent();
38904 wxPyEndAllowThreads(__tstate);
38905 if (PyErr_Occurred()) SWIG_fail;
38906 }
38907 {
38908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38909 }
38910 return resultobj;
38911 fail:
38912 return NULL;
38913 }
38914
38915
38916 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38917 PyObject *resultobj = 0;
38918 wxWindow *arg1 = (wxWindow *) 0 ;
38919 byte arg2 ;
38920 bool result;
38921 void *argp1 = 0 ;
38922 int res1 = 0 ;
38923 unsigned char val2 ;
38924 int ecode2 = 0 ;
38925 PyObject * obj0 = 0 ;
38926 PyObject * obj1 = 0 ;
38927 char * kwnames[] = {
38928 (char *) "self",(char *) "alpha", NULL
38929 };
38930
38931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38933 if (!SWIG_IsOK(res1)) {
38934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38935 }
38936 arg1 = reinterpret_cast< wxWindow * >(argp1);
38937 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38938 if (!SWIG_IsOK(ecode2)) {
38939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38940 }
38941 arg2 = static_cast< byte >(val2);
38942 {
38943 PyThreadState* __tstate = wxPyBeginAllowThreads();
38944 result = (bool)(arg1)->SetTransparent(arg2);
38945 wxPyEndAllowThreads(__tstate);
38946 if (PyErr_Occurred()) SWIG_fail;
38947 }
38948 {
38949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38950 }
38951 return resultobj;
38952 fail:
38953 return NULL;
38954 }
38955
38956
38957 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38958 PyObject *obj;
38959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38960 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38961 return SWIG_Py_Void();
38962 }
38963
38964 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38965 return SWIG_Python_InitShadowInstance(args);
38966 }
38967
38968 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38969 PyObject *resultobj = 0;
38970 long arg1 ;
38971 wxWindow *arg2 = (wxWindow *) NULL ;
38972 wxWindow *result = 0 ;
38973 long val1 ;
38974 int ecode1 = 0 ;
38975 void *argp2 = 0 ;
38976 int res2 = 0 ;
38977 PyObject * obj0 = 0 ;
38978 PyObject * obj1 = 0 ;
38979 char * kwnames[] = {
38980 (char *) "id",(char *) "parent", NULL
38981 };
38982
38983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38984 ecode1 = SWIG_AsVal_long(obj0, &val1);
38985 if (!SWIG_IsOK(ecode1)) {
38986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38987 }
38988 arg1 = static_cast< long >(val1);
38989 if (obj1) {
38990 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38991 if (!SWIG_IsOK(res2)) {
38992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38993 }
38994 arg2 = reinterpret_cast< wxWindow * >(argp2);
38995 }
38996 {
38997 if (!wxPyCheckForApp()) SWIG_fail;
38998 PyThreadState* __tstate = wxPyBeginAllowThreads();
38999 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
39000 wxPyEndAllowThreads(__tstate);
39001 if (PyErr_Occurred()) SWIG_fail;
39002 }
39003 {
39004 resultobj = wxPyMake_wxObject(result, 0);
39005 }
39006 return resultobj;
39007 fail:
39008 return NULL;
39009 }
39010
39011
39012 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39013 PyObject *resultobj = 0;
39014 wxString *arg1 = 0 ;
39015 wxWindow *arg2 = (wxWindow *) NULL ;
39016 wxWindow *result = 0 ;
39017 bool temp1 = false ;
39018 void *argp2 = 0 ;
39019 int res2 = 0 ;
39020 PyObject * obj0 = 0 ;
39021 PyObject * obj1 = 0 ;
39022 char * kwnames[] = {
39023 (char *) "name",(char *) "parent", NULL
39024 };
39025
39026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
39027 {
39028 arg1 = wxString_in_helper(obj0);
39029 if (arg1 == NULL) SWIG_fail;
39030 temp1 = true;
39031 }
39032 if (obj1) {
39033 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39034 if (!SWIG_IsOK(res2)) {
39035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
39036 }
39037 arg2 = reinterpret_cast< wxWindow * >(argp2);
39038 }
39039 {
39040 if (!wxPyCheckForApp()) SWIG_fail;
39041 PyThreadState* __tstate = wxPyBeginAllowThreads();
39042 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
39043 wxPyEndAllowThreads(__tstate);
39044 if (PyErr_Occurred()) SWIG_fail;
39045 }
39046 {
39047 resultobj = wxPyMake_wxObject(result, 0);
39048 }
39049 {
39050 if (temp1)
39051 delete arg1;
39052 }
39053 return resultobj;
39054 fail:
39055 {
39056 if (temp1)
39057 delete arg1;
39058 }
39059 return NULL;
39060 }
39061
39062
39063 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39064 PyObject *resultobj = 0;
39065 wxString *arg1 = 0 ;
39066 wxWindow *arg2 = (wxWindow *) NULL ;
39067 wxWindow *result = 0 ;
39068 bool temp1 = false ;
39069 void *argp2 = 0 ;
39070 int res2 = 0 ;
39071 PyObject * obj0 = 0 ;
39072 PyObject * obj1 = 0 ;
39073 char * kwnames[] = {
39074 (char *) "label",(char *) "parent", NULL
39075 };
39076
39077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39078 {
39079 arg1 = wxString_in_helper(obj0);
39080 if (arg1 == NULL) SWIG_fail;
39081 temp1 = true;
39082 }
39083 if (obj1) {
39084 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39085 if (!SWIG_IsOK(res2)) {
39086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
39087 }
39088 arg2 = reinterpret_cast< wxWindow * >(argp2);
39089 }
39090 {
39091 if (!wxPyCheckForApp()) SWIG_fail;
39092 PyThreadState* __tstate = wxPyBeginAllowThreads();
39093 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
39094 wxPyEndAllowThreads(__tstate);
39095 if (PyErr_Occurred()) SWIG_fail;
39096 }
39097 {
39098 resultobj = wxPyMake_wxObject(result, 0);
39099 }
39100 {
39101 if (temp1)
39102 delete arg1;
39103 }
39104 return resultobj;
39105 fail:
39106 {
39107 if (temp1)
39108 delete arg1;
39109 }
39110 return NULL;
39111 }
39112
39113
39114 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39115 PyObject *resultobj = 0;
39116 wxWindow *arg1 = (wxWindow *) 0 ;
39117 unsigned long arg2 ;
39118 wxWindow *result = 0 ;
39119 void *argp1 = 0 ;
39120 int res1 = 0 ;
39121 unsigned long val2 ;
39122 int ecode2 = 0 ;
39123 PyObject * obj0 = 0 ;
39124 PyObject * obj1 = 0 ;
39125 char * kwnames[] = {
39126 (char *) "parent",(char *) "_hWnd", NULL
39127 };
39128
39129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
39130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39131 if (!SWIG_IsOK(res1)) {
39132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
39133 }
39134 arg1 = reinterpret_cast< wxWindow * >(argp1);
39135 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
39136 if (!SWIG_IsOK(ecode2)) {
39137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
39138 }
39139 arg2 = static_cast< unsigned long >(val2);
39140 {
39141 PyThreadState* __tstate = wxPyBeginAllowThreads();
39142 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
39143 wxPyEndAllowThreads(__tstate);
39144 if (PyErr_Occurred()) SWIG_fail;
39145 }
39146 {
39147 resultobj = wxPyMake_wxObject(result, 0);
39148 }
39149 return resultobj;
39150 fail:
39151 return NULL;
39152 }
39153
39154
39155 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39156 PyObject *resultobj = 0;
39157 PyObject *result = 0 ;
39158
39159 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
39160 {
39161 PyThreadState* __tstate = wxPyBeginAllowThreads();
39162 result = (PyObject *)GetTopLevelWindows();
39163 wxPyEndAllowThreads(__tstate);
39164 if (PyErr_Occurred()) SWIG_fail;
39165 }
39166 resultobj = result;
39167 return resultobj;
39168 fail:
39169 return NULL;
39170 }
39171
39172
39173 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39174 PyObject *resultobj = 0;
39175 wxValidator *result = 0 ;
39176
39177 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
39178 {
39179 PyThreadState* __tstate = wxPyBeginAllowThreads();
39180 result = (wxValidator *)new wxValidator();
39181 wxPyEndAllowThreads(__tstate);
39182 if (PyErr_Occurred()) SWIG_fail;
39183 }
39184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
39185 return resultobj;
39186 fail:
39187 return NULL;
39188 }
39189
39190
39191 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39192 PyObject *resultobj = 0;
39193 wxValidator *arg1 = (wxValidator *) 0 ;
39194 wxValidator *result = 0 ;
39195 void *argp1 = 0 ;
39196 int res1 = 0 ;
39197 PyObject *swig_obj[1] ;
39198
39199 if (!args) SWIG_fail;
39200 swig_obj[0] = args;
39201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39202 if (!SWIG_IsOK(res1)) {
39203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
39204 }
39205 arg1 = reinterpret_cast< wxValidator * >(argp1);
39206 {
39207 PyThreadState* __tstate = wxPyBeginAllowThreads();
39208 result = (wxValidator *)(arg1)->Clone();
39209 wxPyEndAllowThreads(__tstate);
39210 if (PyErr_Occurred()) SWIG_fail;
39211 }
39212 {
39213 resultobj = wxPyMake_wxObject(result, 0);
39214 }
39215 return resultobj;
39216 fail:
39217 return NULL;
39218 }
39219
39220
39221 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39222 PyObject *resultobj = 0;
39223 wxValidator *arg1 = (wxValidator *) 0 ;
39224 wxWindow *arg2 = (wxWindow *) 0 ;
39225 bool result;
39226 void *argp1 = 0 ;
39227 int res1 = 0 ;
39228 void *argp2 = 0 ;
39229 int res2 = 0 ;
39230 PyObject * obj0 = 0 ;
39231 PyObject * obj1 = 0 ;
39232 char * kwnames[] = {
39233 (char *) "self",(char *) "parent", NULL
39234 };
39235
39236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
39237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39238 if (!SWIG_IsOK(res1)) {
39239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
39240 }
39241 arg1 = reinterpret_cast< wxValidator * >(argp1);
39242 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39243 if (!SWIG_IsOK(res2)) {
39244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
39245 }
39246 arg2 = reinterpret_cast< wxWindow * >(argp2);
39247 {
39248 PyThreadState* __tstate = wxPyBeginAllowThreads();
39249 result = (bool)(arg1)->Validate(arg2);
39250 wxPyEndAllowThreads(__tstate);
39251 if (PyErr_Occurred()) SWIG_fail;
39252 }
39253 {
39254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39255 }
39256 return resultobj;
39257 fail:
39258 return NULL;
39259 }
39260
39261
39262 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39263 PyObject *resultobj = 0;
39264 wxValidator *arg1 = (wxValidator *) 0 ;
39265 bool result;
39266 void *argp1 = 0 ;
39267 int res1 = 0 ;
39268 PyObject *swig_obj[1] ;
39269
39270 if (!args) SWIG_fail;
39271 swig_obj[0] = args;
39272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39273 if (!SWIG_IsOK(res1)) {
39274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39275 }
39276 arg1 = reinterpret_cast< wxValidator * >(argp1);
39277 {
39278 PyThreadState* __tstate = wxPyBeginAllowThreads();
39279 result = (bool)(arg1)->TransferToWindow();
39280 wxPyEndAllowThreads(__tstate);
39281 if (PyErr_Occurred()) SWIG_fail;
39282 }
39283 {
39284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39285 }
39286 return resultobj;
39287 fail:
39288 return NULL;
39289 }
39290
39291
39292 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39293 PyObject *resultobj = 0;
39294 wxValidator *arg1 = (wxValidator *) 0 ;
39295 bool result;
39296 void *argp1 = 0 ;
39297 int res1 = 0 ;
39298 PyObject *swig_obj[1] ;
39299
39300 if (!args) SWIG_fail;
39301 swig_obj[0] = args;
39302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39303 if (!SWIG_IsOK(res1)) {
39304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39305 }
39306 arg1 = reinterpret_cast< wxValidator * >(argp1);
39307 {
39308 PyThreadState* __tstate = wxPyBeginAllowThreads();
39309 result = (bool)(arg1)->TransferFromWindow();
39310 wxPyEndAllowThreads(__tstate);
39311 if (PyErr_Occurred()) SWIG_fail;
39312 }
39313 {
39314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39315 }
39316 return resultobj;
39317 fail:
39318 return NULL;
39319 }
39320
39321
39322 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39323 PyObject *resultobj = 0;
39324 wxValidator *arg1 = (wxValidator *) 0 ;
39325 wxWindow *result = 0 ;
39326 void *argp1 = 0 ;
39327 int res1 = 0 ;
39328 PyObject *swig_obj[1] ;
39329
39330 if (!args) SWIG_fail;
39331 swig_obj[0] = args;
39332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39333 if (!SWIG_IsOK(res1)) {
39334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39335 }
39336 arg1 = reinterpret_cast< wxValidator * >(argp1);
39337 {
39338 PyThreadState* __tstate = wxPyBeginAllowThreads();
39339 result = (wxWindow *)(arg1)->GetWindow();
39340 wxPyEndAllowThreads(__tstate);
39341 if (PyErr_Occurred()) SWIG_fail;
39342 }
39343 {
39344 resultobj = wxPyMake_wxObject(result, 0);
39345 }
39346 return resultobj;
39347 fail:
39348 return NULL;
39349 }
39350
39351
39352 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39353 PyObject *resultobj = 0;
39354 wxValidator *arg1 = (wxValidator *) 0 ;
39355 wxWindow *arg2 = (wxWindow *) 0 ;
39356 void *argp1 = 0 ;
39357 int res1 = 0 ;
39358 void *argp2 = 0 ;
39359 int res2 = 0 ;
39360 PyObject * obj0 = 0 ;
39361 PyObject * obj1 = 0 ;
39362 char * kwnames[] = {
39363 (char *) "self",(char *) "window", NULL
39364 };
39365
39366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
39367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39368 if (!SWIG_IsOK(res1)) {
39369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39370 }
39371 arg1 = reinterpret_cast< wxValidator * >(argp1);
39372 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39373 if (!SWIG_IsOK(res2)) {
39374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
39375 }
39376 arg2 = reinterpret_cast< wxWindow * >(argp2);
39377 {
39378 PyThreadState* __tstate = wxPyBeginAllowThreads();
39379 (arg1)->SetWindow(arg2);
39380 wxPyEndAllowThreads(__tstate);
39381 if (PyErr_Occurred()) SWIG_fail;
39382 }
39383 resultobj = SWIG_Py_Void();
39384 return resultobj;
39385 fail:
39386 return NULL;
39387 }
39388
39389
39390 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39391 PyObject *resultobj = 0;
39392 bool result;
39393
39394 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
39395 {
39396 PyThreadState* __tstate = wxPyBeginAllowThreads();
39397 result = (bool)wxValidator::IsSilent();
39398 wxPyEndAllowThreads(__tstate);
39399 if (PyErr_Occurred()) SWIG_fail;
39400 }
39401 {
39402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39403 }
39404 return resultobj;
39405 fail:
39406 return NULL;
39407 }
39408
39409
39410 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39411 PyObject *resultobj = 0;
39412 int arg1 = (int) true ;
39413 int val1 ;
39414 int ecode1 = 0 ;
39415 PyObject * obj0 = 0 ;
39416 char * kwnames[] = {
39417 (char *) "doIt", NULL
39418 };
39419
39420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
39421 if (obj0) {
39422 ecode1 = SWIG_AsVal_int(obj0, &val1);
39423 if (!SWIG_IsOK(ecode1)) {
39424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
39425 }
39426 arg1 = static_cast< int >(val1);
39427 }
39428 {
39429 PyThreadState* __tstate = wxPyBeginAllowThreads();
39430 wxValidator::SetBellOnError(arg1);
39431 wxPyEndAllowThreads(__tstate);
39432 if (PyErr_Occurred()) SWIG_fail;
39433 }
39434 resultobj = SWIG_Py_Void();
39435 return resultobj;
39436 fail:
39437 return NULL;
39438 }
39439
39440
39441 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39442 PyObject *obj;
39443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39444 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
39445 return SWIG_Py_Void();
39446 }
39447
39448 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39449 return SWIG_Python_InitShadowInstance(args);
39450 }
39451
39452 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39453 PyObject *resultobj = 0;
39454 wxPyValidator *result = 0 ;
39455
39456 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
39457 {
39458 PyThreadState* __tstate = wxPyBeginAllowThreads();
39459 result = (wxPyValidator *)new wxPyValidator();
39460 wxPyEndAllowThreads(__tstate);
39461 if (PyErr_Occurred()) SWIG_fail;
39462 }
39463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
39464 return resultobj;
39465 fail:
39466 return NULL;
39467 }
39468
39469
39470 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39471 PyObject *resultobj = 0;
39472 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
39473 PyObject *arg2 = (PyObject *) 0 ;
39474 PyObject *arg3 = (PyObject *) 0 ;
39475 int arg4 = (int) true ;
39476 void *argp1 = 0 ;
39477 int res1 = 0 ;
39478 int val4 ;
39479 int ecode4 = 0 ;
39480 PyObject * obj0 = 0 ;
39481 PyObject * obj1 = 0 ;
39482 PyObject * obj2 = 0 ;
39483 PyObject * obj3 = 0 ;
39484 char * kwnames[] = {
39485 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
39486 };
39487
39488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
39490 if (!SWIG_IsOK(res1)) {
39491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
39492 }
39493 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
39494 arg2 = obj1;
39495 arg3 = obj2;
39496 if (obj3) {
39497 ecode4 = SWIG_AsVal_int(obj3, &val4);
39498 if (!SWIG_IsOK(ecode4)) {
39499 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
39500 }
39501 arg4 = static_cast< int >(val4);
39502 }
39503 {
39504 PyThreadState* __tstate = wxPyBeginAllowThreads();
39505 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
39506 wxPyEndAllowThreads(__tstate);
39507 if (PyErr_Occurred()) SWIG_fail;
39508 }
39509 resultobj = SWIG_Py_Void();
39510 return resultobj;
39511 fail:
39512 return NULL;
39513 }
39514
39515
39516 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39517 PyObject *obj;
39518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39519 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
39520 return SWIG_Py_Void();
39521 }
39522
39523 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39524 return SWIG_Python_InitShadowInstance(args);
39525 }
39526
39527 SWIGINTERN int DefaultValidator_set(PyObject *) {
39528 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
39529 return 1;
39530 }
39531
39532
39533 SWIGINTERN PyObject *DefaultValidator_get(void) {
39534 PyObject *pyobj = 0;
39535
39536 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
39537 return pyobj;
39538 }
39539
39540
39541 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39542 PyObject *resultobj = 0;
39543 wxString const &arg1_defvalue = wxPyEmptyString ;
39544 wxString *arg1 = (wxString *) &arg1_defvalue ;
39545 long arg2 = (long) 0 ;
39546 wxMenu *result = 0 ;
39547 bool temp1 = false ;
39548 long val2 ;
39549 int ecode2 = 0 ;
39550 PyObject * obj0 = 0 ;
39551 PyObject * obj1 = 0 ;
39552 char * kwnames[] = {
39553 (char *) "title",(char *) "style", NULL
39554 };
39555
39556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
39557 if (obj0) {
39558 {
39559 arg1 = wxString_in_helper(obj0);
39560 if (arg1 == NULL) SWIG_fail;
39561 temp1 = true;
39562 }
39563 }
39564 if (obj1) {
39565 ecode2 = SWIG_AsVal_long(obj1, &val2);
39566 if (!SWIG_IsOK(ecode2)) {
39567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
39568 }
39569 arg2 = static_cast< long >(val2);
39570 }
39571 {
39572 if (!wxPyCheckForApp()) SWIG_fail;
39573 PyThreadState* __tstate = wxPyBeginAllowThreads();
39574 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
39575 wxPyEndAllowThreads(__tstate);
39576 if (PyErr_Occurred()) SWIG_fail;
39577 }
39578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
39579 {
39580 if (temp1)
39581 delete arg1;
39582 }
39583 return resultobj;
39584 fail:
39585 {
39586 if (temp1)
39587 delete arg1;
39588 }
39589 return NULL;
39590 }
39591
39592
39593 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39594 PyObject *resultobj = 0;
39595 wxMenu *arg1 = (wxMenu *) 0 ;
39596 int arg2 ;
39597 wxString const &arg3_defvalue = wxPyEmptyString ;
39598 wxString *arg3 = (wxString *) &arg3_defvalue ;
39599 wxString const &arg4_defvalue = wxPyEmptyString ;
39600 wxString *arg4 = (wxString *) &arg4_defvalue ;
39601 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39602 wxMenuItem *result = 0 ;
39603 void *argp1 = 0 ;
39604 int res1 = 0 ;
39605 int val2 ;
39606 int ecode2 = 0 ;
39607 bool temp3 = false ;
39608 bool temp4 = false ;
39609 int val5 ;
39610 int ecode5 = 0 ;
39611 PyObject * obj0 = 0 ;
39612 PyObject * obj1 = 0 ;
39613 PyObject * obj2 = 0 ;
39614 PyObject * obj3 = 0 ;
39615 PyObject * obj4 = 0 ;
39616 char * kwnames[] = {
39617 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39618 };
39619
39620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39622 if (!SWIG_IsOK(res1)) {
39623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39624 }
39625 arg1 = reinterpret_cast< wxMenu * >(argp1);
39626 ecode2 = SWIG_AsVal_int(obj1, &val2);
39627 if (!SWIG_IsOK(ecode2)) {
39628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39629 }
39630 arg2 = static_cast< int >(val2);
39631 if (obj2) {
39632 {
39633 arg3 = wxString_in_helper(obj2);
39634 if (arg3 == NULL) SWIG_fail;
39635 temp3 = true;
39636 }
39637 }
39638 if (obj3) {
39639 {
39640 arg4 = wxString_in_helper(obj3);
39641 if (arg4 == NULL) SWIG_fail;
39642 temp4 = true;
39643 }
39644 }
39645 if (obj4) {
39646 ecode5 = SWIG_AsVal_int(obj4, &val5);
39647 if (!SWIG_IsOK(ecode5)) {
39648 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39649 }
39650 arg5 = static_cast< wxItemKind >(val5);
39651 }
39652 {
39653 PyThreadState* __tstate = wxPyBeginAllowThreads();
39654 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39655 wxPyEndAllowThreads(__tstate);
39656 if (PyErr_Occurred()) SWIG_fail;
39657 }
39658 {
39659 resultobj = wxPyMake_wxObject(result, (bool)0);
39660 }
39661 {
39662 if (temp3)
39663 delete arg3;
39664 }
39665 {
39666 if (temp4)
39667 delete arg4;
39668 }
39669 return resultobj;
39670 fail:
39671 {
39672 if (temp3)
39673 delete arg3;
39674 }
39675 {
39676 if (temp4)
39677 delete arg4;
39678 }
39679 return NULL;
39680 }
39681
39682
39683 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39684 PyObject *resultobj = 0;
39685 wxMenu *arg1 = (wxMenu *) 0 ;
39686 wxMenuItem *result = 0 ;
39687 void *argp1 = 0 ;
39688 int res1 = 0 ;
39689 PyObject *swig_obj[1] ;
39690
39691 if (!args) SWIG_fail;
39692 swig_obj[0] = args;
39693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39694 if (!SWIG_IsOK(res1)) {
39695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39696 }
39697 arg1 = reinterpret_cast< wxMenu * >(argp1);
39698 {
39699 PyThreadState* __tstate = wxPyBeginAllowThreads();
39700 result = (wxMenuItem *)(arg1)->AppendSeparator();
39701 wxPyEndAllowThreads(__tstate);
39702 if (PyErr_Occurred()) SWIG_fail;
39703 }
39704 {
39705 resultobj = wxPyMake_wxObject(result, (bool)0);
39706 }
39707 return resultobj;
39708 fail:
39709 return NULL;
39710 }
39711
39712
39713 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39714 PyObject *resultobj = 0;
39715 wxMenu *arg1 = (wxMenu *) 0 ;
39716 int arg2 ;
39717 wxString *arg3 = 0 ;
39718 wxString const &arg4_defvalue = wxPyEmptyString ;
39719 wxString *arg4 = (wxString *) &arg4_defvalue ;
39720 wxMenuItem *result = 0 ;
39721 void *argp1 = 0 ;
39722 int res1 = 0 ;
39723 int val2 ;
39724 int ecode2 = 0 ;
39725 bool temp3 = false ;
39726 bool temp4 = false ;
39727 PyObject * obj0 = 0 ;
39728 PyObject * obj1 = 0 ;
39729 PyObject * obj2 = 0 ;
39730 PyObject * obj3 = 0 ;
39731 char * kwnames[] = {
39732 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39733 };
39734
39735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39737 if (!SWIG_IsOK(res1)) {
39738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39739 }
39740 arg1 = reinterpret_cast< wxMenu * >(argp1);
39741 ecode2 = SWIG_AsVal_int(obj1, &val2);
39742 if (!SWIG_IsOK(ecode2)) {
39743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39744 }
39745 arg2 = static_cast< int >(val2);
39746 {
39747 arg3 = wxString_in_helper(obj2);
39748 if (arg3 == NULL) SWIG_fail;
39749 temp3 = true;
39750 }
39751 if (obj3) {
39752 {
39753 arg4 = wxString_in_helper(obj3);
39754 if (arg4 == NULL) SWIG_fail;
39755 temp4 = true;
39756 }
39757 }
39758 {
39759 PyThreadState* __tstate = wxPyBeginAllowThreads();
39760 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39761 wxPyEndAllowThreads(__tstate);
39762 if (PyErr_Occurred()) SWIG_fail;
39763 }
39764 {
39765 resultobj = wxPyMake_wxObject(result, (bool)0);
39766 }
39767 {
39768 if (temp3)
39769 delete arg3;
39770 }
39771 {
39772 if (temp4)
39773 delete arg4;
39774 }
39775 return resultobj;
39776 fail:
39777 {
39778 if (temp3)
39779 delete arg3;
39780 }
39781 {
39782 if (temp4)
39783 delete arg4;
39784 }
39785 return NULL;
39786 }
39787
39788
39789 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39790 PyObject *resultobj = 0;
39791 wxMenu *arg1 = (wxMenu *) 0 ;
39792 int arg2 ;
39793 wxString *arg3 = 0 ;
39794 wxString const &arg4_defvalue = wxPyEmptyString ;
39795 wxString *arg4 = (wxString *) &arg4_defvalue ;
39796 wxMenuItem *result = 0 ;
39797 void *argp1 = 0 ;
39798 int res1 = 0 ;
39799 int val2 ;
39800 int ecode2 = 0 ;
39801 bool temp3 = false ;
39802 bool temp4 = false ;
39803 PyObject * obj0 = 0 ;
39804 PyObject * obj1 = 0 ;
39805 PyObject * obj2 = 0 ;
39806 PyObject * obj3 = 0 ;
39807 char * kwnames[] = {
39808 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39809 };
39810
39811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39813 if (!SWIG_IsOK(res1)) {
39814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39815 }
39816 arg1 = reinterpret_cast< wxMenu * >(argp1);
39817 ecode2 = SWIG_AsVal_int(obj1, &val2);
39818 if (!SWIG_IsOK(ecode2)) {
39819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39820 }
39821 arg2 = static_cast< int >(val2);
39822 {
39823 arg3 = wxString_in_helper(obj2);
39824 if (arg3 == NULL) SWIG_fail;
39825 temp3 = true;
39826 }
39827 if (obj3) {
39828 {
39829 arg4 = wxString_in_helper(obj3);
39830 if (arg4 == NULL) SWIG_fail;
39831 temp4 = true;
39832 }
39833 }
39834 {
39835 PyThreadState* __tstate = wxPyBeginAllowThreads();
39836 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39837 wxPyEndAllowThreads(__tstate);
39838 if (PyErr_Occurred()) SWIG_fail;
39839 }
39840 {
39841 resultobj = wxPyMake_wxObject(result, (bool)0);
39842 }
39843 {
39844 if (temp3)
39845 delete arg3;
39846 }
39847 {
39848 if (temp4)
39849 delete arg4;
39850 }
39851 return resultobj;
39852 fail:
39853 {
39854 if (temp3)
39855 delete arg3;
39856 }
39857 {
39858 if (temp4)
39859 delete arg4;
39860 }
39861 return NULL;
39862 }
39863
39864
39865 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39866 PyObject *resultobj = 0;
39867 wxMenu *arg1 = (wxMenu *) 0 ;
39868 int arg2 ;
39869 wxString *arg3 = 0 ;
39870 wxMenu *arg4 = (wxMenu *) 0 ;
39871 wxString const &arg5_defvalue = wxPyEmptyString ;
39872 wxString *arg5 = (wxString *) &arg5_defvalue ;
39873 wxMenuItem *result = 0 ;
39874 void *argp1 = 0 ;
39875 int res1 = 0 ;
39876 int val2 ;
39877 int ecode2 = 0 ;
39878 bool temp3 = false ;
39879 void *argp4 = 0 ;
39880 int res4 = 0 ;
39881 bool temp5 = false ;
39882 PyObject * obj0 = 0 ;
39883 PyObject * obj1 = 0 ;
39884 PyObject * obj2 = 0 ;
39885 PyObject * obj3 = 0 ;
39886 PyObject * obj4 = 0 ;
39887 char * kwnames[] = {
39888 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39889 };
39890
39891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39893 if (!SWIG_IsOK(res1)) {
39894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39895 }
39896 arg1 = reinterpret_cast< wxMenu * >(argp1);
39897 ecode2 = SWIG_AsVal_int(obj1, &val2);
39898 if (!SWIG_IsOK(ecode2)) {
39899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39900 }
39901 arg2 = static_cast< int >(val2);
39902 {
39903 arg3 = wxString_in_helper(obj2);
39904 if (arg3 == NULL) SWIG_fail;
39905 temp3 = true;
39906 }
39907 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39908 if (!SWIG_IsOK(res4)) {
39909 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39910 }
39911 arg4 = reinterpret_cast< wxMenu * >(argp4);
39912 if (obj4) {
39913 {
39914 arg5 = wxString_in_helper(obj4);
39915 if (arg5 == NULL) SWIG_fail;
39916 temp5 = true;
39917 }
39918 }
39919 {
39920 PyThreadState* __tstate = wxPyBeginAllowThreads();
39921 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39922 wxPyEndAllowThreads(__tstate);
39923 if (PyErr_Occurred()) SWIG_fail;
39924 }
39925 {
39926 resultobj = wxPyMake_wxObject(result, (bool)0);
39927 }
39928 {
39929 if (temp3)
39930 delete arg3;
39931 }
39932 {
39933 if (temp5)
39934 delete arg5;
39935 }
39936 return resultobj;
39937 fail:
39938 {
39939 if (temp3)
39940 delete arg3;
39941 }
39942 {
39943 if (temp5)
39944 delete arg5;
39945 }
39946 return NULL;
39947 }
39948
39949
39950 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39951 PyObject *resultobj = 0;
39952 wxMenu *arg1 = (wxMenu *) 0 ;
39953 wxMenu *arg2 = (wxMenu *) 0 ;
39954 wxString *arg3 = 0 ;
39955 wxString const &arg4_defvalue = wxPyEmptyString ;
39956 wxString *arg4 = (wxString *) &arg4_defvalue ;
39957 wxMenuItem *result = 0 ;
39958 void *argp1 = 0 ;
39959 int res1 = 0 ;
39960 void *argp2 = 0 ;
39961 int res2 = 0 ;
39962 bool temp3 = false ;
39963 bool temp4 = false ;
39964 PyObject * obj0 = 0 ;
39965 PyObject * obj1 = 0 ;
39966 PyObject * obj2 = 0 ;
39967 PyObject * obj3 = 0 ;
39968 char * kwnames[] = {
39969 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39970 };
39971
39972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39974 if (!SWIG_IsOK(res1)) {
39975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39976 }
39977 arg1 = reinterpret_cast< wxMenu * >(argp1);
39978 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39979 if (!SWIG_IsOK(res2)) {
39980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39981 }
39982 arg2 = reinterpret_cast< wxMenu * >(argp2);
39983 {
39984 arg3 = wxString_in_helper(obj2);
39985 if (arg3 == NULL) SWIG_fail;
39986 temp3 = true;
39987 }
39988 if (obj3) {
39989 {
39990 arg4 = wxString_in_helper(obj3);
39991 if (arg4 == NULL) SWIG_fail;
39992 temp4 = true;
39993 }
39994 }
39995 {
39996 PyThreadState* __tstate = wxPyBeginAllowThreads();
39997 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39998 wxPyEndAllowThreads(__tstate);
39999 if (PyErr_Occurred()) SWIG_fail;
40000 }
40001 {
40002 resultobj = wxPyMake_wxObject(result, (bool)0);
40003 }
40004 {
40005 if (temp3)
40006 delete arg3;
40007 }
40008 {
40009 if (temp4)
40010 delete arg4;
40011 }
40012 return resultobj;
40013 fail:
40014 {
40015 if (temp3)
40016 delete arg3;
40017 }
40018 {
40019 if (temp4)
40020 delete arg4;
40021 }
40022 return NULL;
40023 }
40024
40025
40026 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40027 PyObject *resultobj = 0;
40028 wxMenu *arg1 = (wxMenu *) 0 ;
40029 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40030 wxMenuItem *result = 0 ;
40031 void *argp1 = 0 ;
40032 int res1 = 0 ;
40033 int res2 = 0 ;
40034 PyObject * obj0 = 0 ;
40035 PyObject * obj1 = 0 ;
40036 char * kwnames[] = {
40037 (char *) "self",(char *) "item", NULL
40038 };
40039
40040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
40041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40042 if (!SWIG_IsOK(res1)) {
40043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40044 }
40045 arg1 = reinterpret_cast< wxMenu * >(argp1);
40046 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40047 if (!SWIG_IsOK(res2)) {
40048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40049 }
40050 {
40051 PyThreadState* __tstate = wxPyBeginAllowThreads();
40052 result = (wxMenuItem *)(arg1)->Append(arg2);
40053 wxPyEndAllowThreads(__tstate);
40054 if (PyErr_Occurred()) SWIG_fail;
40055 }
40056 {
40057 resultobj = wxPyMake_wxObject(result, (bool)0);
40058 }
40059 return resultobj;
40060 fail:
40061 return NULL;
40062 }
40063
40064
40065 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40066 PyObject *resultobj = 0;
40067 wxMenu *arg1 = (wxMenu *) 0 ;
40068 size_t arg2 ;
40069 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
40070 wxMenuItem *result = 0 ;
40071 void *argp1 = 0 ;
40072 int res1 = 0 ;
40073 size_t val2 ;
40074 int ecode2 = 0 ;
40075 int res3 = 0 ;
40076 PyObject * obj0 = 0 ;
40077 PyObject * obj1 = 0 ;
40078 PyObject * obj2 = 0 ;
40079 char * kwnames[] = {
40080 (char *) "self",(char *) "pos",(char *) "item", NULL
40081 };
40082
40083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40085 if (!SWIG_IsOK(res1)) {
40086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40087 }
40088 arg1 = reinterpret_cast< wxMenu * >(argp1);
40089 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40090 if (!SWIG_IsOK(ecode2)) {
40091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
40092 }
40093 arg2 = static_cast< size_t >(val2);
40094 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40095 if (!SWIG_IsOK(res3)) {
40096 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
40097 }
40098 {
40099 PyThreadState* __tstate = wxPyBeginAllowThreads();
40100 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
40101 wxPyEndAllowThreads(__tstate);
40102 if (PyErr_Occurred()) SWIG_fail;
40103 }
40104 {
40105 resultobj = wxPyMake_wxObject(result, (bool)0);
40106 }
40107 return resultobj;
40108 fail:
40109 return NULL;
40110 }
40111
40112
40113 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40114 PyObject *resultobj = 0;
40115 wxMenu *arg1 = (wxMenu *) 0 ;
40116 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40117 wxMenuItem *result = 0 ;
40118 void *argp1 = 0 ;
40119 int res1 = 0 ;
40120 int res2 = 0 ;
40121 PyObject * obj0 = 0 ;
40122 PyObject * obj1 = 0 ;
40123 char * kwnames[] = {
40124 (char *) "self",(char *) "item", NULL
40125 };
40126
40127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
40128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40129 if (!SWIG_IsOK(res1)) {
40130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40131 }
40132 arg1 = reinterpret_cast< wxMenu * >(argp1);
40133 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40134 if (!SWIG_IsOK(res2)) {
40135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40136 }
40137 {
40138 PyThreadState* __tstate = wxPyBeginAllowThreads();
40139 result = (wxMenuItem *)(arg1)->Prepend(arg2);
40140 wxPyEndAllowThreads(__tstate);
40141 if (PyErr_Occurred()) SWIG_fail;
40142 }
40143 {
40144 resultobj = wxPyMake_wxObject(result, (bool)0);
40145 }
40146 return resultobj;
40147 fail:
40148 return NULL;
40149 }
40150
40151
40152 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40153 PyObject *resultobj = 0;
40154 wxMenu *arg1 = (wxMenu *) 0 ;
40155 void *argp1 = 0 ;
40156 int res1 = 0 ;
40157 PyObject *swig_obj[1] ;
40158
40159 if (!args) SWIG_fail;
40160 swig_obj[0] = args;
40161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40162 if (!SWIG_IsOK(res1)) {
40163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
40164 }
40165 arg1 = reinterpret_cast< wxMenu * >(argp1);
40166 {
40167 PyThreadState* __tstate = wxPyBeginAllowThreads();
40168 (arg1)->Break();
40169 wxPyEndAllowThreads(__tstate);
40170 if (PyErr_Occurred()) SWIG_fail;
40171 }
40172 resultobj = SWIG_Py_Void();
40173 return resultobj;
40174 fail:
40175 return NULL;
40176 }
40177
40178
40179 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40180 PyObject *resultobj = 0;
40181 wxMenu *arg1 = (wxMenu *) 0 ;
40182 size_t arg2 ;
40183 int arg3 ;
40184 wxString const &arg4_defvalue = wxPyEmptyString ;
40185 wxString *arg4 = (wxString *) &arg4_defvalue ;
40186 wxString const &arg5_defvalue = wxPyEmptyString ;
40187 wxString *arg5 = (wxString *) &arg5_defvalue ;
40188 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
40189 wxMenuItem *result = 0 ;
40190 void *argp1 = 0 ;
40191 int res1 = 0 ;
40192 size_t val2 ;
40193 int ecode2 = 0 ;
40194 int val3 ;
40195 int ecode3 = 0 ;
40196 bool temp4 = false ;
40197 bool temp5 = false ;
40198 int val6 ;
40199 int ecode6 = 0 ;
40200 PyObject * obj0 = 0 ;
40201 PyObject * obj1 = 0 ;
40202 PyObject * obj2 = 0 ;
40203 PyObject * obj3 = 0 ;
40204 PyObject * obj4 = 0 ;
40205 PyObject * obj5 = 0 ;
40206 char * kwnames[] = {
40207 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40208 };
40209
40210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40212 if (!SWIG_IsOK(res1)) {
40213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
40214 }
40215 arg1 = reinterpret_cast< wxMenu * >(argp1);
40216 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40217 if (!SWIG_IsOK(ecode2)) {
40218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
40219 }
40220 arg2 = static_cast< size_t >(val2);
40221 ecode3 = SWIG_AsVal_int(obj2, &val3);
40222 if (!SWIG_IsOK(ecode3)) {
40223 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
40224 }
40225 arg3 = static_cast< int >(val3);
40226 if (obj3) {
40227 {
40228 arg4 = wxString_in_helper(obj3);
40229 if (arg4 == NULL) SWIG_fail;
40230 temp4 = true;
40231 }
40232 }
40233 if (obj4) {
40234 {
40235 arg5 = wxString_in_helper(obj4);
40236 if (arg5 == NULL) SWIG_fail;
40237 temp5 = true;
40238 }
40239 }
40240 if (obj5) {
40241 ecode6 = SWIG_AsVal_int(obj5, &val6);
40242 if (!SWIG_IsOK(ecode6)) {
40243 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
40244 }
40245 arg6 = static_cast< wxItemKind >(val6);
40246 }
40247 {
40248 PyThreadState* __tstate = wxPyBeginAllowThreads();
40249 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
40250 wxPyEndAllowThreads(__tstate);
40251 if (PyErr_Occurred()) SWIG_fail;
40252 }
40253 {
40254 resultobj = wxPyMake_wxObject(result, (bool)0);
40255 }
40256 {
40257 if (temp4)
40258 delete arg4;
40259 }
40260 {
40261 if (temp5)
40262 delete arg5;
40263 }
40264 return resultobj;
40265 fail:
40266 {
40267 if (temp4)
40268 delete arg4;
40269 }
40270 {
40271 if (temp5)
40272 delete arg5;
40273 }
40274 return NULL;
40275 }
40276
40277
40278 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40279 PyObject *resultobj = 0;
40280 wxMenu *arg1 = (wxMenu *) 0 ;
40281 size_t arg2 ;
40282 wxMenuItem *result = 0 ;
40283 void *argp1 = 0 ;
40284 int res1 = 0 ;
40285 size_t val2 ;
40286 int ecode2 = 0 ;
40287 PyObject * obj0 = 0 ;
40288 PyObject * obj1 = 0 ;
40289 char * kwnames[] = {
40290 (char *) "self",(char *) "pos", NULL
40291 };
40292
40293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
40294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40295 if (!SWIG_IsOK(res1)) {
40296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40297 }
40298 arg1 = reinterpret_cast< wxMenu * >(argp1);
40299 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40300 if (!SWIG_IsOK(ecode2)) {
40301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
40302 }
40303 arg2 = static_cast< size_t >(val2);
40304 {
40305 PyThreadState* __tstate = wxPyBeginAllowThreads();
40306 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
40307 wxPyEndAllowThreads(__tstate);
40308 if (PyErr_Occurred()) SWIG_fail;
40309 }
40310 {
40311 resultobj = wxPyMake_wxObject(result, (bool)0);
40312 }
40313 return resultobj;
40314 fail:
40315 return NULL;
40316 }
40317
40318
40319 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40320 PyObject *resultobj = 0;
40321 wxMenu *arg1 = (wxMenu *) 0 ;
40322 size_t arg2 ;
40323 int arg3 ;
40324 wxString *arg4 = 0 ;
40325 wxString const &arg5_defvalue = wxPyEmptyString ;
40326 wxString *arg5 = (wxString *) &arg5_defvalue ;
40327 wxMenuItem *result = 0 ;
40328 void *argp1 = 0 ;
40329 int res1 = 0 ;
40330 size_t val2 ;
40331 int ecode2 = 0 ;
40332 int val3 ;
40333 int ecode3 = 0 ;
40334 bool temp4 = false ;
40335 bool temp5 = false ;
40336 PyObject * obj0 = 0 ;
40337 PyObject * obj1 = 0 ;
40338 PyObject * obj2 = 0 ;
40339 PyObject * obj3 = 0 ;
40340 PyObject * obj4 = 0 ;
40341 char * kwnames[] = {
40342 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40343 };
40344
40345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40347 if (!SWIG_IsOK(res1)) {
40348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40349 }
40350 arg1 = reinterpret_cast< wxMenu * >(argp1);
40351 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40352 if (!SWIG_IsOK(ecode2)) {
40353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
40354 }
40355 arg2 = static_cast< size_t >(val2);
40356 ecode3 = SWIG_AsVal_int(obj2, &val3);
40357 if (!SWIG_IsOK(ecode3)) {
40358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
40359 }
40360 arg3 = static_cast< int >(val3);
40361 {
40362 arg4 = wxString_in_helper(obj3);
40363 if (arg4 == NULL) SWIG_fail;
40364 temp4 = true;
40365 }
40366 if (obj4) {
40367 {
40368 arg5 = wxString_in_helper(obj4);
40369 if (arg5 == NULL) SWIG_fail;
40370 temp5 = true;
40371 }
40372 }
40373 {
40374 PyThreadState* __tstate = wxPyBeginAllowThreads();
40375 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40376 wxPyEndAllowThreads(__tstate);
40377 if (PyErr_Occurred()) SWIG_fail;
40378 }
40379 {
40380 resultobj = wxPyMake_wxObject(result, (bool)0);
40381 }
40382 {
40383 if (temp4)
40384 delete arg4;
40385 }
40386 {
40387 if (temp5)
40388 delete arg5;
40389 }
40390 return resultobj;
40391 fail:
40392 {
40393 if (temp4)
40394 delete arg4;
40395 }
40396 {
40397 if (temp5)
40398 delete arg5;
40399 }
40400 return NULL;
40401 }
40402
40403
40404 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40405 PyObject *resultobj = 0;
40406 wxMenu *arg1 = (wxMenu *) 0 ;
40407 size_t arg2 ;
40408 int arg3 ;
40409 wxString *arg4 = 0 ;
40410 wxString const &arg5_defvalue = wxPyEmptyString ;
40411 wxString *arg5 = (wxString *) &arg5_defvalue ;
40412 wxMenuItem *result = 0 ;
40413 void *argp1 = 0 ;
40414 int res1 = 0 ;
40415 size_t val2 ;
40416 int ecode2 = 0 ;
40417 int val3 ;
40418 int ecode3 = 0 ;
40419 bool temp4 = false ;
40420 bool temp5 = false ;
40421 PyObject * obj0 = 0 ;
40422 PyObject * obj1 = 0 ;
40423 PyObject * obj2 = 0 ;
40424 PyObject * obj3 = 0 ;
40425 PyObject * obj4 = 0 ;
40426 char * kwnames[] = {
40427 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40428 };
40429
40430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40432 if (!SWIG_IsOK(res1)) {
40433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40434 }
40435 arg1 = reinterpret_cast< wxMenu * >(argp1);
40436 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40437 if (!SWIG_IsOK(ecode2)) {
40438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
40439 }
40440 arg2 = static_cast< size_t >(val2);
40441 ecode3 = SWIG_AsVal_int(obj2, &val3);
40442 if (!SWIG_IsOK(ecode3)) {
40443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
40444 }
40445 arg3 = static_cast< int >(val3);
40446 {
40447 arg4 = wxString_in_helper(obj3);
40448 if (arg4 == NULL) SWIG_fail;
40449 temp4 = true;
40450 }
40451 if (obj4) {
40452 {
40453 arg5 = wxString_in_helper(obj4);
40454 if (arg5 == NULL) SWIG_fail;
40455 temp5 = true;
40456 }
40457 }
40458 {
40459 PyThreadState* __tstate = wxPyBeginAllowThreads();
40460 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40461 wxPyEndAllowThreads(__tstate);
40462 if (PyErr_Occurred()) SWIG_fail;
40463 }
40464 {
40465 resultobj = wxPyMake_wxObject(result, (bool)0);
40466 }
40467 {
40468 if (temp4)
40469 delete arg4;
40470 }
40471 {
40472 if (temp5)
40473 delete arg5;
40474 }
40475 return resultobj;
40476 fail:
40477 {
40478 if (temp4)
40479 delete arg4;
40480 }
40481 {
40482 if (temp5)
40483 delete arg5;
40484 }
40485 return NULL;
40486 }
40487
40488
40489 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40490 PyObject *resultobj = 0;
40491 wxMenu *arg1 = (wxMenu *) 0 ;
40492 size_t arg2 ;
40493 int arg3 ;
40494 wxString *arg4 = 0 ;
40495 wxMenu *arg5 = (wxMenu *) 0 ;
40496 wxString const &arg6_defvalue = wxPyEmptyString ;
40497 wxString *arg6 = (wxString *) &arg6_defvalue ;
40498 wxMenuItem *result = 0 ;
40499 void *argp1 = 0 ;
40500 int res1 = 0 ;
40501 size_t val2 ;
40502 int ecode2 = 0 ;
40503 int val3 ;
40504 int ecode3 = 0 ;
40505 bool temp4 = false ;
40506 void *argp5 = 0 ;
40507 int res5 = 0 ;
40508 bool temp6 = false ;
40509 PyObject * obj0 = 0 ;
40510 PyObject * obj1 = 0 ;
40511 PyObject * obj2 = 0 ;
40512 PyObject * obj3 = 0 ;
40513 PyObject * obj4 = 0 ;
40514 PyObject * obj5 = 0 ;
40515 char * kwnames[] = {
40516 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40517 };
40518
40519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40521 if (!SWIG_IsOK(res1)) {
40522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40523 }
40524 arg1 = reinterpret_cast< wxMenu * >(argp1);
40525 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40526 if (!SWIG_IsOK(ecode2)) {
40527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
40528 }
40529 arg2 = static_cast< size_t >(val2);
40530 ecode3 = SWIG_AsVal_int(obj2, &val3);
40531 if (!SWIG_IsOK(ecode3)) {
40532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
40533 }
40534 arg3 = static_cast< int >(val3);
40535 {
40536 arg4 = wxString_in_helper(obj3);
40537 if (arg4 == NULL) SWIG_fail;
40538 temp4 = true;
40539 }
40540 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
40541 if (!SWIG_IsOK(res5)) {
40542 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
40543 }
40544 arg5 = reinterpret_cast< wxMenu * >(argp5);
40545 if (obj5) {
40546 {
40547 arg6 = wxString_in_helper(obj5);
40548 if (arg6 == NULL) SWIG_fail;
40549 temp6 = true;
40550 }
40551 }
40552 {
40553 PyThreadState* __tstate = wxPyBeginAllowThreads();
40554 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
40555 wxPyEndAllowThreads(__tstate);
40556 if (PyErr_Occurred()) SWIG_fail;
40557 }
40558 {
40559 resultobj = wxPyMake_wxObject(result, (bool)0);
40560 }
40561 {
40562 if (temp4)
40563 delete arg4;
40564 }
40565 {
40566 if (temp6)
40567 delete arg6;
40568 }
40569 return resultobj;
40570 fail:
40571 {
40572 if (temp4)
40573 delete arg4;
40574 }
40575 {
40576 if (temp6)
40577 delete arg6;
40578 }
40579 return NULL;
40580 }
40581
40582
40583 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40584 PyObject *resultobj = 0;
40585 wxMenu *arg1 = (wxMenu *) 0 ;
40586 int arg2 ;
40587 wxString const &arg3_defvalue = wxPyEmptyString ;
40588 wxString *arg3 = (wxString *) &arg3_defvalue ;
40589 wxString const &arg4_defvalue = wxPyEmptyString ;
40590 wxString *arg4 = (wxString *) &arg4_defvalue ;
40591 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40592 wxMenuItem *result = 0 ;
40593 void *argp1 = 0 ;
40594 int res1 = 0 ;
40595 int val2 ;
40596 int ecode2 = 0 ;
40597 bool temp3 = false ;
40598 bool temp4 = false ;
40599 int val5 ;
40600 int ecode5 = 0 ;
40601 PyObject * obj0 = 0 ;
40602 PyObject * obj1 = 0 ;
40603 PyObject * obj2 = 0 ;
40604 PyObject * obj3 = 0 ;
40605 PyObject * obj4 = 0 ;
40606 char * kwnames[] = {
40607 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40608 };
40609
40610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40612 if (!SWIG_IsOK(res1)) {
40613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40614 }
40615 arg1 = reinterpret_cast< wxMenu * >(argp1);
40616 ecode2 = SWIG_AsVal_int(obj1, &val2);
40617 if (!SWIG_IsOK(ecode2)) {
40618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40619 }
40620 arg2 = static_cast< int >(val2);
40621 if (obj2) {
40622 {
40623 arg3 = wxString_in_helper(obj2);
40624 if (arg3 == NULL) SWIG_fail;
40625 temp3 = true;
40626 }
40627 }
40628 if (obj3) {
40629 {
40630 arg4 = wxString_in_helper(obj3);
40631 if (arg4 == NULL) SWIG_fail;
40632 temp4 = true;
40633 }
40634 }
40635 if (obj4) {
40636 ecode5 = SWIG_AsVal_int(obj4, &val5);
40637 if (!SWIG_IsOK(ecode5)) {
40638 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40639 }
40640 arg5 = static_cast< wxItemKind >(val5);
40641 }
40642 {
40643 PyThreadState* __tstate = wxPyBeginAllowThreads();
40644 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40645 wxPyEndAllowThreads(__tstate);
40646 if (PyErr_Occurred()) SWIG_fail;
40647 }
40648 {
40649 resultobj = wxPyMake_wxObject(result, (bool)0);
40650 }
40651 {
40652 if (temp3)
40653 delete arg3;
40654 }
40655 {
40656 if (temp4)
40657 delete arg4;
40658 }
40659 return resultobj;
40660 fail:
40661 {
40662 if (temp3)
40663 delete arg3;
40664 }
40665 {
40666 if (temp4)
40667 delete arg4;
40668 }
40669 return NULL;
40670 }
40671
40672
40673 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40674 PyObject *resultobj = 0;
40675 wxMenu *arg1 = (wxMenu *) 0 ;
40676 wxMenuItem *result = 0 ;
40677 void *argp1 = 0 ;
40678 int res1 = 0 ;
40679 PyObject *swig_obj[1] ;
40680
40681 if (!args) SWIG_fail;
40682 swig_obj[0] = args;
40683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40684 if (!SWIG_IsOK(res1)) {
40685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40686 }
40687 arg1 = reinterpret_cast< wxMenu * >(argp1);
40688 {
40689 PyThreadState* __tstate = wxPyBeginAllowThreads();
40690 result = (wxMenuItem *)(arg1)->PrependSeparator();
40691 wxPyEndAllowThreads(__tstate);
40692 if (PyErr_Occurred()) SWIG_fail;
40693 }
40694 {
40695 resultobj = wxPyMake_wxObject(result, (bool)0);
40696 }
40697 return resultobj;
40698 fail:
40699 return NULL;
40700 }
40701
40702
40703 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40704 PyObject *resultobj = 0;
40705 wxMenu *arg1 = (wxMenu *) 0 ;
40706 int arg2 ;
40707 wxString *arg3 = 0 ;
40708 wxString const &arg4_defvalue = wxPyEmptyString ;
40709 wxString *arg4 = (wxString *) &arg4_defvalue ;
40710 wxMenuItem *result = 0 ;
40711 void *argp1 = 0 ;
40712 int res1 = 0 ;
40713 int val2 ;
40714 int ecode2 = 0 ;
40715 bool temp3 = false ;
40716 bool temp4 = false ;
40717 PyObject * obj0 = 0 ;
40718 PyObject * obj1 = 0 ;
40719 PyObject * obj2 = 0 ;
40720 PyObject * obj3 = 0 ;
40721 char * kwnames[] = {
40722 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40723 };
40724
40725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40727 if (!SWIG_IsOK(res1)) {
40728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40729 }
40730 arg1 = reinterpret_cast< wxMenu * >(argp1);
40731 ecode2 = SWIG_AsVal_int(obj1, &val2);
40732 if (!SWIG_IsOK(ecode2)) {
40733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40734 }
40735 arg2 = static_cast< int >(val2);
40736 {
40737 arg3 = wxString_in_helper(obj2);
40738 if (arg3 == NULL) SWIG_fail;
40739 temp3 = true;
40740 }
40741 if (obj3) {
40742 {
40743 arg4 = wxString_in_helper(obj3);
40744 if (arg4 == NULL) SWIG_fail;
40745 temp4 = true;
40746 }
40747 }
40748 {
40749 PyThreadState* __tstate = wxPyBeginAllowThreads();
40750 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40751 wxPyEndAllowThreads(__tstate);
40752 if (PyErr_Occurred()) SWIG_fail;
40753 }
40754 {
40755 resultobj = wxPyMake_wxObject(result, (bool)0);
40756 }
40757 {
40758 if (temp3)
40759 delete arg3;
40760 }
40761 {
40762 if (temp4)
40763 delete arg4;
40764 }
40765 return resultobj;
40766 fail:
40767 {
40768 if (temp3)
40769 delete arg3;
40770 }
40771 {
40772 if (temp4)
40773 delete arg4;
40774 }
40775 return NULL;
40776 }
40777
40778
40779 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40780 PyObject *resultobj = 0;
40781 wxMenu *arg1 = (wxMenu *) 0 ;
40782 int arg2 ;
40783 wxString *arg3 = 0 ;
40784 wxString const &arg4_defvalue = wxPyEmptyString ;
40785 wxString *arg4 = (wxString *) &arg4_defvalue ;
40786 wxMenuItem *result = 0 ;
40787 void *argp1 = 0 ;
40788 int res1 = 0 ;
40789 int val2 ;
40790 int ecode2 = 0 ;
40791 bool temp3 = false ;
40792 bool temp4 = false ;
40793 PyObject * obj0 = 0 ;
40794 PyObject * obj1 = 0 ;
40795 PyObject * obj2 = 0 ;
40796 PyObject * obj3 = 0 ;
40797 char * kwnames[] = {
40798 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40799 };
40800
40801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40803 if (!SWIG_IsOK(res1)) {
40804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40805 }
40806 arg1 = reinterpret_cast< wxMenu * >(argp1);
40807 ecode2 = SWIG_AsVal_int(obj1, &val2);
40808 if (!SWIG_IsOK(ecode2)) {
40809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40810 }
40811 arg2 = static_cast< int >(val2);
40812 {
40813 arg3 = wxString_in_helper(obj2);
40814 if (arg3 == NULL) SWIG_fail;
40815 temp3 = true;
40816 }
40817 if (obj3) {
40818 {
40819 arg4 = wxString_in_helper(obj3);
40820 if (arg4 == NULL) SWIG_fail;
40821 temp4 = true;
40822 }
40823 }
40824 {
40825 PyThreadState* __tstate = wxPyBeginAllowThreads();
40826 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40827 wxPyEndAllowThreads(__tstate);
40828 if (PyErr_Occurred()) SWIG_fail;
40829 }
40830 {
40831 resultobj = wxPyMake_wxObject(result, (bool)0);
40832 }
40833 {
40834 if (temp3)
40835 delete arg3;
40836 }
40837 {
40838 if (temp4)
40839 delete arg4;
40840 }
40841 return resultobj;
40842 fail:
40843 {
40844 if (temp3)
40845 delete arg3;
40846 }
40847 {
40848 if (temp4)
40849 delete arg4;
40850 }
40851 return NULL;
40852 }
40853
40854
40855 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40856 PyObject *resultobj = 0;
40857 wxMenu *arg1 = (wxMenu *) 0 ;
40858 int arg2 ;
40859 wxString *arg3 = 0 ;
40860 wxMenu *arg4 = (wxMenu *) 0 ;
40861 wxString const &arg5_defvalue = wxPyEmptyString ;
40862 wxString *arg5 = (wxString *) &arg5_defvalue ;
40863 wxMenuItem *result = 0 ;
40864 void *argp1 = 0 ;
40865 int res1 = 0 ;
40866 int val2 ;
40867 int ecode2 = 0 ;
40868 bool temp3 = false ;
40869 void *argp4 = 0 ;
40870 int res4 = 0 ;
40871 bool temp5 = false ;
40872 PyObject * obj0 = 0 ;
40873 PyObject * obj1 = 0 ;
40874 PyObject * obj2 = 0 ;
40875 PyObject * obj3 = 0 ;
40876 PyObject * obj4 = 0 ;
40877 char * kwnames[] = {
40878 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40879 };
40880
40881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40883 if (!SWIG_IsOK(res1)) {
40884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40885 }
40886 arg1 = reinterpret_cast< wxMenu * >(argp1);
40887 ecode2 = SWIG_AsVal_int(obj1, &val2);
40888 if (!SWIG_IsOK(ecode2)) {
40889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40890 }
40891 arg2 = static_cast< int >(val2);
40892 {
40893 arg3 = wxString_in_helper(obj2);
40894 if (arg3 == NULL) SWIG_fail;
40895 temp3 = true;
40896 }
40897 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40898 if (!SWIG_IsOK(res4)) {
40899 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40900 }
40901 arg4 = reinterpret_cast< wxMenu * >(argp4);
40902 if (obj4) {
40903 {
40904 arg5 = wxString_in_helper(obj4);
40905 if (arg5 == NULL) SWIG_fail;
40906 temp5 = true;
40907 }
40908 }
40909 {
40910 PyThreadState* __tstate = wxPyBeginAllowThreads();
40911 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40912 wxPyEndAllowThreads(__tstate);
40913 if (PyErr_Occurred()) SWIG_fail;
40914 }
40915 {
40916 resultobj = wxPyMake_wxObject(result, (bool)0);
40917 }
40918 {
40919 if (temp3)
40920 delete arg3;
40921 }
40922 {
40923 if (temp5)
40924 delete arg5;
40925 }
40926 return resultobj;
40927 fail:
40928 {
40929 if (temp3)
40930 delete arg3;
40931 }
40932 {
40933 if (temp5)
40934 delete arg5;
40935 }
40936 return NULL;
40937 }
40938
40939
40940 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40941 PyObject *resultobj = 0;
40942 wxMenu *arg1 = (wxMenu *) 0 ;
40943 int arg2 ;
40944 wxMenuItem *result = 0 ;
40945 void *argp1 = 0 ;
40946 int res1 = 0 ;
40947 int val2 ;
40948 int ecode2 = 0 ;
40949 PyObject * obj0 = 0 ;
40950 PyObject * obj1 = 0 ;
40951 char * kwnames[] = {
40952 (char *) "self",(char *) "id", NULL
40953 };
40954
40955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40957 if (!SWIG_IsOK(res1)) {
40958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40959 }
40960 arg1 = reinterpret_cast< wxMenu * >(argp1);
40961 ecode2 = SWIG_AsVal_int(obj1, &val2);
40962 if (!SWIG_IsOK(ecode2)) {
40963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40964 }
40965 arg2 = static_cast< int >(val2);
40966 {
40967 PyThreadState* __tstate = wxPyBeginAllowThreads();
40968 result = (wxMenuItem *)(arg1)->Remove(arg2);
40969 wxPyEndAllowThreads(__tstate);
40970 if (PyErr_Occurred()) SWIG_fail;
40971 }
40972 {
40973 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40974 }
40975 return resultobj;
40976 fail:
40977 return NULL;
40978 }
40979
40980
40981 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40982 PyObject *resultobj = 0;
40983 wxMenu *arg1 = (wxMenu *) 0 ;
40984 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40985 wxMenuItem *result = 0 ;
40986 void *argp1 = 0 ;
40987 int res1 = 0 ;
40988 void *argp2 = 0 ;
40989 int res2 = 0 ;
40990 PyObject * obj0 = 0 ;
40991 PyObject * obj1 = 0 ;
40992 char * kwnames[] = {
40993 (char *) "self",(char *) "item", NULL
40994 };
40995
40996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40998 if (!SWIG_IsOK(res1)) {
40999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41000 }
41001 arg1 = reinterpret_cast< wxMenu * >(argp1);
41002 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41003 if (!SWIG_IsOK(res2)) {
41004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41005 }
41006 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41007 {
41008 PyThreadState* __tstate = wxPyBeginAllowThreads();
41009 result = (wxMenuItem *)(arg1)->Remove(arg2);
41010 wxPyEndAllowThreads(__tstate);
41011 if (PyErr_Occurred()) SWIG_fail;
41012 }
41013 {
41014 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
41015 }
41016 return resultobj;
41017 fail:
41018 return NULL;
41019 }
41020
41021
41022 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41023 PyObject *resultobj = 0;
41024 wxMenu *arg1 = (wxMenu *) 0 ;
41025 int arg2 ;
41026 bool result;
41027 void *argp1 = 0 ;
41028 int res1 = 0 ;
41029 int val2 ;
41030 int ecode2 = 0 ;
41031 PyObject * obj0 = 0 ;
41032 PyObject * obj1 = 0 ;
41033 char * kwnames[] = {
41034 (char *) "self",(char *) "id", NULL
41035 };
41036
41037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
41038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41039 if (!SWIG_IsOK(res1)) {
41040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
41041 }
41042 arg1 = reinterpret_cast< wxMenu * >(argp1);
41043 ecode2 = SWIG_AsVal_int(obj1, &val2);
41044 if (!SWIG_IsOK(ecode2)) {
41045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
41046 }
41047 arg2 = static_cast< int >(val2);
41048 {
41049 PyThreadState* __tstate = wxPyBeginAllowThreads();
41050 result = (bool)(arg1)->Delete(arg2);
41051 wxPyEndAllowThreads(__tstate);
41052 if (PyErr_Occurred()) SWIG_fail;
41053 }
41054 {
41055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41056 }
41057 return resultobj;
41058 fail:
41059 return NULL;
41060 }
41061
41062
41063 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41064 PyObject *resultobj = 0;
41065 wxMenu *arg1 = (wxMenu *) 0 ;
41066 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41067 bool result;
41068 void *argp1 = 0 ;
41069 int res1 = 0 ;
41070 void *argp2 = 0 ;
41071 int res2 = 0 ;
41072 PyObject * obj0 = 0 ;
41073 PyObject * obj1 = 0 ;
41074 char * kwnames[] = {
41075 (char *) "self",(char *) "item", NULL
41076 };
41077
41078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
41079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41080 if (!SWIG_IsOK(res1)) {
41081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41082 }
41083 arg1 = reinterpret_cast< wxMenu * >(argp1);
41084 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41085 if (!SWIG_IsOK(res2)) {
41086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41087 }
41088 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41089 {
41090 PyThreadState* __tstate = wxPyBeginAllowThreads();
41091 result = (bool)(arg1)->Delete(arg2);
41092 wxPyEndAllowThreads(__tstate);
41093 if (PyErr_Occurred()) SWIG_fail;
41094 }
41095 {
41096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41097 }
41098 return resultobj;
41099 fail:
41100 return NULL;
41101 }
41102
41103
41104 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41105 PyObject *resultobj = 0;
41106 wxMenu *arg1 = (wxMenu *) 0 ;
41107 void *argp1 = 0 ;
41108 int res1 = 0 ;
41109 PyObject *swig_obj[1] ;
41110
41111 if (!args) SWIG_fail;
41112 swig_obj[0] = args;
41113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41114 if (!SWIG_IsOK(res1)) {
41115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
41116 }
41117 arg1 = reinterpret_cast< wxMenu * >(argp1);
41118 {
41119 PyThreadState* __tstate = wxPyBeginAllowThreads();
41120 wxMenu_Destroy(arg1);
41121 wxPyEndAllowThreads(__tstate);
41122 if (PyErr_Occurred()) SWIG_fail;
41123 }
41124 resultobj = SWIG_Py_Void();
41125 return resultobj;
41126 fail:
41127 return NULL;
41128 }
41129
41130
41131 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41132 PyObject *resultobj = 0;
41133 wxMenu *arg1 = (wxMenu *) 0 ;
41134 int arg2 ;
41135 bool result;
41136 void *argp1 = 0 ;
41137 int res1 = 0 ;
41138 int val2 ;
41139 int ecode2 = 0 ;
41140 PyObject * obj0 = 0 ;
41141 PyObject * obj1 = 0 ;
41142 char * kwnames[] = {
41143 (char *) "self",(char *) "id", NULL
41144 };
41145
41146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
41147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41148 if (!SWIG_IsOK(res1)) {
41149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
41150 }
41151 arg1 = reinterpret_cast< wxMenu * >(argp1);
41152 ecode2 = SWIG_AsVal_int(obj1, &val2);
41153 if (!SWIG_IsOK(ecode2)) {
41154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
41155 }
41156 arg2 = static_cast< int >(val2);
41157 {
41158 PyThreadState* __tstate = wxPyBeginAllowThreads();
41159 result = (bool)(arg1)->Destroy(arg2);
41160 wxPyEndAllowThreads(__tstate);
41161 if (PyErr_Occurred()) SWIG_fail;
41162 }
41163 {
41164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41165 }
41166 return resultobj;
41167 fail:
41168 return NULL;
41169 }
41170
41171
41172 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41173 PyObject *resultobj = 0;
41174 wxMenu *arg1 = (wxMenu *) 0 ;
41175 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41176 bool result;
41177 void *argp1 = 0 ;
41178 int res1 = 0 ;
41179 void *argp2 = 0 ;
41180 int res2 = 0 ;
41181 PyObject * obj0 = 0 ;
41182 PyObject * obj1 = 0 ;
41183 char * kwnames[] = {
41184 (char *) "self",(char *) "item", NULL
41185 };
41186
41187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
41188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41189 if (!SWIG_IsOK(res1)) {
41190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41191 }
41192 arg1 = reinterpret_cast< wxMenu * >(argp1);
41193 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41194 if (!SWIG_IsOK(res2)) {
41195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41196 }
41197 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41198 {
41199 PyThreadState* __tstate = wxPyBeginAllowThreads();
41200 result = (bool)(arg1)->Destroy(arg2);
41201 wxPyEndAllowThreads(__tstate);
41202 if (PyErr_Occurred()) SWIG_fail;
41203 }
41204 {
41205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41206 }
41207 return resultobj;
41208 fail:
41209 return NULL;
41210 }
41211
41212
41213 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41214 PyObject *resultobj = 0;
41215 wxMenu *arg1 = (wxMenu *) 0 ;
41216 size_t result;
41217 void *argp1 = 0 ;
41218 int res1 = 0 ;
41219 PyObject *swig_obj[1] ;
41220
41221 if (!args) SWIG_fail;
41222 swig_obj[0] = args;
41223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41224 if (!SWIG_IsOK(res1)) {
41225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
41226 }
41227 arg1 = reinterpret_cast< wxMenu * >(argp1);
41228 {
41229 PyThreadState* __tstate = wxPyBeginAllowThreads();
41230 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
41231 wxPyEndAllowThreads(__tstate);
41232 if (PyErr_Occurred()) SWIG_fail;
41233 }
41234 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41235 return resultobj;
41236 fail:
41237 return NULL;
41238 }
41239
41240
41241 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41242 PyObject *resultobj = 0;
41243 wxMenu *arg1 = (wxMenu *) 0 ;
41244 PyObject *result = 0 ;
41245 void *argp1 = 0 ;
41246 int res1 = 0 ;
41247 PyObject *swig_obj[1] ;
41248
41249 if (!args) SWIG_fail;
41250 swig_obj[0] = args;
41251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41252 if (!SWIG_IsOK(res1)) {
41253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
41254 }
41255 arg1 = reinterpret_cast< wxMenu * >(argp1);
41256 {
41257 PyThreadState* __tstate = wxPyBeginAllowThreads();
41258 result = (PyObject *)wxMenu_GetMenuItems(arg1);
41259 wxPyEndAllowThreads(__tstate);
41260 if (PyErr_Occurred()) SWIG_fail;
41261 }
41262 resultobj = result;
41263 return resultobj;
41264 fail:
41265 return NULL;
41266 }
41267
41268
41269 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41270 PyObject *resultobj = 0;
41271 wxMenu *arg1 = (wxMenu *) 0 ;
41272 wxString *arg2 = 0 ;
41273 int result;
41274 void *argp1 = 0 ;
41275 int res1 = 0 ;
41276 bool temp2 = false ;
41277 PyObject * obj0 = 0 ;
41278 PyObject * obj1 = 0 ;
41279 char * kwnames[] = {
41280 (char *) "self",(char *) "item", NULL
41281 };
41282
41283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
41284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41285 if (!SWIG_IsOK(res1)) {
41286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
41287 }
41288 arg1 = reinterpret_cast< wxMenu * >(argp1);
41289 {
41290 arg2 = wxString_in_helper(obj1);
41291 if (arg2 == NULL) SWIG_fail;
41292 temp2 = true;
41293 }
41294 {
41295 PyThreadState* __tstate = wxPyBeginAllowThreads();
41296 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
41297 wxPyEndAllowThreads(__tstate);
41298 if (PyErr_Occurred()) SWIG_fail;
41299 }
41300 resultobj = SWIG_From_int(static_cast< int >(result));
41301 {
41302 if (temp2)
41303 delete arg2;
41304 }
41305 return resultobj;
41306 fail:
41307 {
41308 if (temp2)
41309 delete arg2;
41310 }
41311 return NULL;
41312 }
41313
41314
41315 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41316 PyObject *resultobj = 0;
41317 wxMenu *arg1 = (wxMenu *) 0 ;
41318 int arg2 ;
41319 wxMenuItem *result = 0 ;
41320 void *argp1 = 0 ;
41321 int res1 = 0 ;
41322 int val2 ;
41323 int ecode2 = 0 ;
41324 PyObject * obj0 = 0 ;
41325 PyObject * obj1 = 0 ;
41326 char * kwnames[] = {
41327 (char *) "self",(char *) "id", NULL
41328 };
41329
41330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41332 if (!SWIG_IsOK(res1)) {
41333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
41334 }
41335 arg1 = reinterpret_cast< wxMenu * >(argp1);
41336 ecode2 = SWIG_AsVal_int(obj1, &val2);
41337 if (!SWIG_IsOK(ecode2)) {
41338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
41339 }
41340 arg2 = static_cast< int >(val2);
41341 {
41342 PyThreadState* __tstate = wxPyBeginAllowThreads();
41343 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
41344 wxPyEndAllowThreads(__tstate);
41345 if (PyErr_Occurred()) SWIG_fail;
41346 }
41347 {
41348 resultobj = wxPyMake_wxObject(result, (bool)0);
41349 }
41350 return resultobj;
41351 fail:
41352 return NULL;
41353 }
41354
41355
41356 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41357 PyObject *resultobj = 0;
41358 wxMenu *arg1 = (wxMenu *) 0 ;
41359 size_t arg2 ;
41360 wxMenuItem *result = 0 ;
41361 void *argp1 = 0 ;
41362 int res1 = 0 ;
41363 size_t val2 ;
41364 int ecode2 = 0 ;
41365 PyObject * obj0 = 0 ;
41366 PyObject * obj1 = 0 ;
41367 char * kwnames[] = {
41368 (char *) "self",(char *) "position", NULL
41369 };
41370
41371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
41372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41373 if (!SWIG_IsOK(res1)) {
41374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
41375 }
41376 arg1 = reinterpret_cast< wxMenu * >(argp1);
41377 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41378 if (!SWIG_IsOK(ecode2)) {
41379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
41380 }
41381 arg2 = static_cast< size_t >(val2);
41382 {
41383 PyThreadState* __tstate = wxPyBeginAllowThreads();
41384 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
41385 wxPyEndAllowThreads(__tstate);
41386 if (PyErr_Occurred()) SWIG_fail;
41387 }
41388 {
41389 resultobj = wxPyMake_wxObject(result, (bool)0);
41390 }
41391 return resultobj;
41392 fail:
41393 return NULL;
41394 }
41395
41396
41397 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41398 PyObject *resultobj = 0;
41399 wxMenu *arg1 = (wxMenu *) 0 ;
41400 int arg2 ;
41401 bool arg3 ;
41402 void *argp1 = 0 ;
41403 int res1 = 0 ;
41404 int val2 ;
41405 int ecode2 = 0 ;
41406 bool val3 ;
41407 int ecode3 = 0 ;
41408 PyObject * obj0 = 0 ;
41409 PyObject * obj1 = 0 ;
41410 PyObject * obj2 = 0 ;
41411 char * kwnames[] = {
41412 (char *) "self",(char *) "id",(char *) "enable", NULL
41413 };
41414
41415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41417 if (!SWIG_IsOK(res1)) {
41418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
41419 }
41420 arg1 = reinterpret_cast< wxMenu * >(argp1);
41421 ecode2 = SWIG_AsVal_int(obj1, &val2);
41422 if (!SWIG_IsOK(ecode2)) {
41423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
41424 }
41425 arg2 = static_cast< int >(val2);
41426 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41427 if (!SWIG_IsOK(ecode3)) {
41428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
41429 }
41430 arg3 = static_cast< bool >(val3);
41431 {
41432 PyThreadState* __tstate = wxPyBeginAllowThreads();
41433 (arg1)->Enable(arg2,arg3);
41434 wxPyEndAllowThreads(__tstate);
41435 if (PyErr_Occurred()) SWIG_fail;
41436 }
41437 resultobj = SWIG_Py_Void();
41438 return resultobj;
41439 fail:
41440 return NULL;
41441 }
41442
41443
41444 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41445 PyObject *resultobj = 0;
41446 wxMenu *arg1 = (wxMenu *) 0 ;
41447 int arg2 ;
41448 bool result;
41449 void *argp1 = 0 ;
41450 int res1 = 0 ;
41451 int val2 ;
41452 int ecode2 = 0 ;
41453 PyObject * obj0 = 0 ;
41454 PyObject * obj1 = 0 ;
41455 char * kwnames[] = {
41456 (char *) "self",(char *) "id", NULL
41457 };
41458
41459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41461 if (!SWIG_IsOK(res1)) {
41462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
41463 }
41464 arg1 = reinterpret_cast< wxMenu * >(argp1);
41465 ecode2 = SWIG_AsVal_int(obj1, &val2);
41466 if (!SWIG_IsOK(ecode2)) {
41467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41468 }
41469 arg2 = static_cast< int >(val2);
41470 {
41471 PyThreadState* __tstate = wxPyBeginAllowThreads();
41472 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
41473 wxPyEndAllowThreads(__tstate);
41474 if (PyErr_Occurred()) SWIG_fail;
41475 }
41476 {
41477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41478 }
41479 return resultobj;
41480 fail:
41481 return NULL;
41482 }
41483
41484
41485 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41486 PyObject *resultobj = 0;
41487 wxMenu *arg1 = (wxMenu *) 0 ;
41488 int arg2 ;
41489 bool arg3 ;
41490 void *argp1 = 0 ;
41491 int res1 = 0 ;
41492 int val2 ;
41493 int ecode2 = 0 ;
41494 bool val3 ;
41495 int ecode3 = 0 ;
41496 PyObject * obj0 = 0 ;
41497 PyObject * obj1 = 0 ;
41498 PyObject * obj2 = 0 ;
41499 char * kwnames[] = {
41500 (char *) "self",(char *) "id",(char *) "check", NULL
41501 };
41502
41503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41505 if (!SWIG_IsOK(res1)) {
41506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
41507 }
41508 arg1 = reinterpret_cast< wxMenu * >(argp1);
41509 ecode2 = SWIG_AsVal_int(obj1, &val2);
41510 if (!SWIG_IsOK(ecode2)) {
41511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
41512 }
41513 arg2 = static_cast< int >(val2);
41514 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41515 if (!SWIG_IsOK(ecode3)) {
41516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
41517 }
41518 arg3 = static_cast< bool >(val3);
41519 {
41520 PyThreadState* __tstate = wxPyBeginAllowThreads();
41521 (arg1)->Check(arg2,arg3);
41522 wxPyEndAllowThreads(__tstate);
41523 if (PyErr_Occurred()) SWIG_fail;
41524 }
41525 resultobj = SWIG_Py_Void();
41526 return resultobj;
41527 fail:
41528 return NULL;
41529 }
41530
41531
41532 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41533 PyObject *resultobj = 0;
41534 wxMenu *arg1 = (wxMenu *) 0 ;
41535 int arg2 ;
41536 bool result;
41537 void *argp1 = 0 ;
41538 int res1 = 0 ;
41539 int val2 ;
41540 int ecode2 = 0 ;
41541 PyObject * obj0 = 0 ;
41542 PyObject * obj1 = 0 ;
41543 char * kwnames[] = {
41544 (char *) "self",(char *) "id", NULL
41545 };
41546
41547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41549 if (!SWIG_IsOK(res1)) {
41550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
41551 }
41552 arg1 = reinterpret_cast< wxMenu * >(argp1);
41553 ecode2 = SWIG_AsVal_int(obj1, &val2);
41554 if (!SWIG_IsOK(ecode2)) {
41555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
41556 }
41557 arg2 = static_cast< int >(val2);
41558 {
41559 PyThreadState* __tstate = wxPyBeginAllowThreads();
41560 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
41561 wxPyEndAllowThreads(__tstate);
41562 if (PyErr_Occurred()) SWIG_fail;
41563 }
41564 {
41565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41566 }
41567 return resultobj;
41568 fail:
41569 return NULL;
41570 }
41571
41572
41573 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41574 PyObject *resultobj = 0;
41575 wxMenu *arg1 = (wxMenu *) 0 ;
41576 int arg2 ;
41577 wxString *arg3 = 0 ;
41578 void *argp1 = 0 ;
41579 int res1 = 0 ;
41580 int val2 ;
41581 int ecode2 = 0 ;
41582 bool temp3 = false ;
41583 PyObject * obj0 = 0 ;
41584 PyObject * obj1 = 0 ;
41585 PyObject * obj2 = 0 ;
41586 char * kwnames[] = {
41587 (char *) "self",(char *) "id",(char *) "label", NULL
41588 };
41589
41590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41592 if (!SWIG_IsOK(res1)) {
41593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41594 }
41595 arg1 = reinterpret_cast< wxMenu * >(argp1);
41596 ecode2 = SWIG_AsVal_int(obj1, &val2);
41597 if (!SWIG_IsOK(ecode2)) {
41598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41599 }
41600 arg2 = static_cast< int >(val2);
41601 {
41602 arg3 = wxString_in_helper(obj2);
41603 if (arg3 == NULL) SWIG_fail;
41604 temp3 = true;
41605 }
41606 {
41607 PyThreadState* __tstate = wxPyBeginAllowThreads();
41608 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41609 wxPyEndAllowThreads(__tstate);
41610 if (PyErr_Occurred()) SWIG_fail;
41611 }
41612 resultobj = SWIG_Py_Void();
41613 {
41614 if (temp3)
41615 delete arg3;
41616 }
41617 return resultobj;
41618 fail:
41619 {
41620 if (temp3)
41621 delete arg3;
41622 }
41623 return NULL;
41624 }
41625
41626
41627 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41628 PyObject *resultobj = 0;
41629 wxMenu *arg1 = (wxMenu *) 0 ;
41630 int arg2 ;
41631 wxString result;
41632 void *argp1 = 0 ;
41633 int res1 = 0 ;
41634 int val2 ;
41635 int ecode2 = 0 ;
41636 PyObject * obj0 = 0 ;
41637 PyObject * obj1 = 0 ;
41638 char * kwnames[] = {
41639 (char *) "self",(char *) "id", NULL
41640 };
41641
41642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41644 if (!SWIG_IsOK(res1)) {
41645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41646 }
41647 arg1 = reinterpret_cast< wxMenu * >(argp1);
41648 ecode2 = SWIG_AsVal_int(obj1, &val2);
41649 if (!SWIG_IsOK(ecode2)) {
41650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41651 }
41652 arg2 = static_cast< int >(val2);
41653 {
41654 PyThreadState* __tstate = wxPyBeginAllowThreads();
41655 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41656 wxPyEndAllowThreads(__tstate);
41657 if (PyErr_Occurred()) SWIG_fail;
41658 }
41659 {
41660 #if wxUSE_UNICODE
41661 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41662 #else
41663 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41664 #endif
41665 }
41666 return resultobj;
41667 fail:
41668 return NULL;
41669 }
41670
41671
41672 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41673 PyObject *resultobj = 0;
41674 wxMenu *arg1 = (wxMenu *) 0 ;
41675 int arg2 ;
41676 wxString *arg3 = 0 ;
41677 void *argp1 = 0 ;
41678 int res1 = 0 ;
41679 int val2 ;
41680 int ecode2 = 0 ;
41681 bool temp3 = false ;
41682 PyObject * obj0 = 0 ;
41683 PyObject * obj1 = 0 ;
41684 PyObject * obj2 = 0 ;
41685 char * kwnames[] = {
41686 (char *) "self",(char *) "id",(char *) "helpString", NULL
41687 };
41688
41689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41691 if (!SWIG_IsOK(res1)) {
41692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41693 }
41694 arg1 = reinterpret_cast< wxMenu * >(argp1);
41695 ecode2 = SWIG_AsVal_int(obj1, &val2);
41696 if (!SWIG_IsOK(ecode2)) {
41697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41698 }
41699 arg2 = static_cast< int >(val2);
41700 {
41701 arg3 = wxString_in_helper(obj2);
41702 if (arg3 == NULL) SWIG_fail;
41703 temp3 = true;
41704 }
41705 {
41706 PyThreadState* __tstate = wxPyBeginAllowThreads();
41707 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41708 wxPyEndAllowThreads(__tstate);
41709 if (PyErr_Occurred()) SWIG_fail;
41710 }
41711 resultobj = SWIG_Py_Void();
41712 {
41713 if (temp3)
41714 delete arg3;
41715 }
41716 return resultobj;
41717 fail:
41718 {
41719 if (temp3)
41720 delete arg3;
41721 }
41722 return NULL;
41723 }
41724
41725
41726 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41727 PyObject *resultobj = 0;
41728 wxMenu *arg1 = (wxMenu *) 0 ;
41729 int arg2 ;
41730 wxString result;
41731 void *argp1 = 0 ;
41732 int res1 = 0 ;
41733 int val2 ;
41734 int ecode2 = 0 ;
41735 PyObject * obj0 = 0 ;
41736 PyObject * obj1 = 0 ;
41737 char * kwnames[] = {
41738 (char *) "self",(char *) "id", NULL
41739 };
41740
41741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41743 if (!SWIG_IsOK(res1)) {
41744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41745 }
41746 arg1 = reinterpret_cast< wxMenu * >(argp1);
41747 ecode2 = SWIG_AsVal_int(obj1, &val2);
41748 if (!SWIG_IsOK(ecode2)) {
41749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41750 }
41751 arg2 = static_cast< int >(val2);
41752 {
41753 PyThreadState* __tstate = wxPyBeginAllowThreads();
41754 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41755 wxPyEndAllowThreads(__tstate);
41756 if (PyErr_Occurred()) SWIG_fail;
41757 }
41758 {
41759 #if wxUSE_UNICODE
41760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41761 #else
41762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41763 #endif
41764 }
41765 return resultobj;
41766 fail:
41767 return NULL;
41768 }
41769
41770
41771 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41772 PyObject *resultobj = 0;
41773 wxMenu *arg1 = (wxMenu *) 0 ;
41774 wxString *arg2 = 0 ;
41775 void *argp1 = 0 ;
41776 int res1 = 0 ;
41777 bool temp2 = false ;
41778 PyObject * obj0 = 0 ;
41779 PyObject * obj1 = 0 ;
41780 char * kwnames[] = {
41781 (char *) "self",(char *) "title", NULL
41782 };
41783
41784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41786 if (!SWIG_IsOK(res1)) {
41787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41788 }
41789 arg1 = reinterpret_cast< wxMenu * >(argp1);
41790 {
41791 arg2 = wxString_in_helper(obj1);
41792 if (arg2 == NULL) SWIG_fail;
41793 temp2 = true;
41794 }
41795 {
41796 PyThreadState* __tstate = wxPyBeginAllowThreads();
41797 (arg1)->SetTitle((wxString const &)*arg2);
41798 wxPyEndAllowThreads(__tstate);
41799 if (PyErr_Occurred()) SWIG_fail;
41800 }
41801 resultobj = SWIG_Py_Void();
41802 {
41803 if (temp2)
41804 delete arg2;
41805 }
41806 return resultobj;
41807 fail:
41808 {
41809 if (temp2)
41810 delete arg2;
41811 }
41812 return NULL;
41813 }
41814
41815
41816 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41817 PyObject *resultobj = 0;
41818 wxMenu *arg1 = (wxMenu *) 0 ;
41819 wxString result;
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_wxMenu, 0 | 0 );
41827 if (!SWIG_IsOK(res1)) {
41828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41829 }
41830 arg1 = reinterpret_cast< wxMenu * >(argp1);
41831 {
41832 PyThreadState* __tstate = wxPyBeginAllowThreads();
41833 result = ((wxMenu const *)arg1)->GetTitle();
41834 wxPyEndAllowThreads(__tstate);
41835 if (PyErr_Occurred()) SWIG_fail;
41836 }
41837 {
41838 #if wxUSE_UNICODE
41839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41840 #else
41841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41842 #endif
41843 }
41844 return resultobj;
41845 fail:
41846 return NULL;
41847 }
41848
41849
41850 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41851 PyObject *resultobj = 0;
41852 wxMenu *arg1 = (wxMenu *) 0 ;
41853 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41854 void *argp1 = 0 ;
41855 int res1 = 0 ;
41856 void *argp2 = 0 ;
41857 int res2 = 0 ;
41858 PyObject * obj0 = 0 ;
41859 PyObject * obj1 = 0 ;
41860 char * kwnames[] = {
41861 (char *) "self",(char *) "handler", NULL
41862 };
41863
41864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41866 if (!SWIG_IsOK(res1)) {
41867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41868 }
41869 arg1 = reinterpret_cast< wxMenu * >(argp1);
41870 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41871 if (!SWIG_IsOK(res2)) {
41872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41873 }
41874 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41875 {
41876 PyThreadState* __tstate = wxPyBeginAllowThreads();
41877 (arg1)->SetEventHandler(arg2);
41878 wxPyEndAllowThreads(__tstate);
41879 if (PyErr_Occurred()) SWIG_fail;
41880 }
41881 resultobj = SWIG_Py_Void();
41882 return resultobj;
41883 fail:
41884 return NULL;
41885 }
41886
41887
41888 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41889 PyObject *resultobj = 0;
41890 wxMenu *arg1 = (wxMenu *) 0 ;
41891 wxEvtHandler *result = 0 ;
41892 void *argp1 = 0 ;
41893 int res1 = 0 ;
41894 PyObject *swig_obj[1] ;
41895
41896 if (!args) SWIG_fail;
41897 swig_obj[0] = args;
41898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41899 if (!SWIG_IsOK(res1)) {
41900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41901 }
41902 arg1 = reinterpret_cast< wxMenu * >(argp1);
41903 {
41904 PyThreadState* __tstate = wxPyBeginAllowThreads();
41905 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41906 wxPyEndAllowThreads(__tstate);
41907 if (PyErr_Occurred()) SWIG_fail;
41908 }
41909 {
41910 resultobj = wxPyMake_wxObject(result, 0);
41911 }
41912 return resultobj;
41913 fail:
41914 return NULL;
41915 }
41916
41917
41918 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41919 PyObject *resultobj = 0;
41920 wxMenu *arg1 = (wxMenu *) 0 ;
41921 wxWindow *arg2 = (wxWindow *) 0 ;
41922 void *argp1 = 0 ;
41923 int res1 = 0 ;
41924 void *argp2 = 0 ;
41925 int res2 = 0 ;
41926 PyObject * obj0 = 0 ;
41927 PyObject * obj1 = 0 ;
41928 char * kwnames[] = {
41929 (char *) "self",(char *) "win", NULL
41930 };
41931
41932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41934 if (!SWIG_IsOK(res1)) {
41935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41936 }
41937 arg1 = reinterpret_cast< wxMenu * >(argp1);
41938 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41939 if (!SWIG_IsOK(res2)) {
41940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41941 }
41942 arg2 = reinterpret_cast< wxWindow * >(argp2);
41943 {
41944 PyThreadState* __tstate = wxPyBeginAllowThreads();
41945 (arg1)->SetInvokingWindow(arg2);
41946 wxPyEndAllowThreads(__tstate);
41947 if (PyErr_Occurred()) SWIG_fail;
41948 }
41949 resultobj = SWIG_Py_Void();
41950 return resultobj;
41951 fail:
41952 return NULL;
41953 }
41954
41955
41956 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41957 PyObject *resultobj = 0;
41958 wxMenu *arg1 = (wxMenu *) 0 ;
41959 wxWindow *result = 0 ;
41960 void *argp1 = 0 ;
41961 int res1 = 0 ;
41962 PyObject *swig_obj[1] ;
41963
41964 if (!args) SWIG_fail;
41965 swig_obj[0] = args;
41966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41967 if (!SWIG_IsOK(res1)) {
41968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41969 }
41970 arg1 = reinterpret_cast< wxMenu * >(argp1);
41971 {
41972 PyThreadState* __tstate = wxPyBeginAllowThreads();
41973 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41974 wxPyEndAllowThreads(__tstate);
41975 if (PyErr_Occurred()) SWIG_fail;
41976 }
41977 {
41978 resultobj = wxPyMake_wxObject(result, 0);
41979 }
41980 return resultobj;
41981 fail:
41982 return NULL;
41983 }
41984
41985
41986 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41987 PyObject *resultobj = 0;
41988 wxMenu *arg1 = (wxMenu *) 0 ;
41989 long result;
41990 void *argp1 = 0 ;
41991 int res1 = 0 ;
41992 PyObject *swig_obj[1] ;
41993
41994 if (!args) SWIG_fail;
41995 swig_obj[0] = args;
41996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41997 if (!SWIG_IsOK(res1)) {
41998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41999 }
42000 arg1 = reinterpret_cast< wxMenu * >(argp1);
42001 {
42002 PyThreadState* __tstate = wxPyBeginAllowThreads();
42003 result = (long)((wxMenu const *)arg1)->GetStyle();
42004 wxPyEndAllowThreads(__tstate);
42005 if (PyErr_Occurred()) SWIG_fail;
42006 }
42007 resultobj = SWIG_From_long(static_cast< long >(result));
42008 return resultobj;
42009 fail:
42010 return NULL;
42011 }
42012
42013
42014 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42015 PyObject *resultobj = 0;
42016 wxMenu *arg1 = (wxMenu *) 0 ;
42017 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
42018 void *argp1 = 0 ;
42019 int res1 = 0 ;
42020 void *argp2 = 0 ;
42021 int res2 = 0 ;
42022 PyObject * obj0 = 0 ;
42023 PyObject * obj1 = 0 ;
42024 char * kwnames[] = {
42025 (char *) "self",(char *) "source", NULL
42026 };
42027
42028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
42029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42030 if (!SWIG_IsOK(res1)) {
42031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
42032 }
42033 arg1 = reinterpret_cast< wxMenu * >(argp1);
42034 if (obj1) {
42035 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
42036 if (!SWIG_IsOK(res2)) {
42037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
42038 }
42039 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
42040 }
42041 {
42042 PyThreadState* __tstate = wxPyBeginAllowThreads();
42043 (arg1)->UpdateUI(arg2);
42044 wxPyEndAllowThreads(__tstate);
42045 if (PyErr_Occurred()) SWIG_fail;
42046 }
42047 resultobj = SWIG_Py_Void();
42048 return resultobj;
42049 fail:
42050 return NULL;
42051 }
42052
42053
42054 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42055 PyObject *resultobj = 0;
42056 wxMenu *arg1 = (wxMenu *) 0 ;
42057 wxMenuBar *result = 0 ;
42058 void *argp1 = 0 ;
42059 int res1 = 0 ;
42060 PyObject *swig_obj[1] ;
42061
42062 if (!args) SWIG_fail;
42063 swig_obj[0] = args;
42064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42065 if (!SWIG_IsOK(res1)) {
42066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
42067 }
42068 arg1 = reinterpret_cast< wxMenu * >(argp1);
42069 {
42070 PyThreadState* __tstate = wxPyBeginAllowThreads();
42071 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
42072 wxPyEndAllowThreads(__tstate);
42073 if (PyErr_Occurred()) SWIG_fail;
42074 }
42075 {
42076 resultobj = wxPyMake_wxObject(result, (bool)0);
42077 }
42078 return resultobj;
42079 fail:
42080 return NULL;
42081 }
42082
42083
42084 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42085 PyObject *resultobj = 0;
42086 wxMenu *arg1 = (wxMenu *) 0 ;
42087 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
42088 void *argp1 = 0 ;
42089 int res1 = 0 ;
42090 void *argp2 = 0 ;
42091 int res2 = 0 ;
42092 PyObject * obj0 = 0 ;
42093 PyObject * obj1 = 0 ;
42094 char * kwnames[] = {
42095 (char *) "self",(char *) "menubar", NULL
42096 };
42097
42098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42100 if (!SWIG_IsOK(res1)) {
42101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
42102 }
42103 arg1 = reinterpret_cast< wxMenu * >(argp1);
42104 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
42105 if (!SWIG_IsOK(res2)) {
42106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
42107 }
42108 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
42109 {
42110 PyThreadState* __tstate = wxPyBeginAllowThreads();
42111 (arg1)->Attach(arg2);
42112 wxPyEndAllowThreads(__tstate);
42113 if (PyErr_Occurred()) SWIG_fail;
42114 }
42115 resultobj = SWIG_Py_Void();
42116 return resultobj;
42117 fail:
42118 return NULL;
42119 }
42120
42121
42122 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42123 PyObject *resultobj = 0;
42124 wxMenu *arg1 = (wxMenu *) 0 ;
42125 void *argp1 = 0 ;
42126 int res1 = 0 ;
42127 PyObject *swig_obj[1] ;
42128
42129 if (!args) SWIG_fail;
42130 swig_obj[0] = args;
42131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42132 if (!SWIG_IsOK(res1)) {
42133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
42134 }
42135 arg1 = reinterpret_cast< wxMenu * >(argp1);
42136 {
42137 PyThreadState* __tstate = wxPyBeginAllowThreads();
42138 (arg1)->Detach();
42139 wxPyEndAllowThreads(__tstate);
42140 if (PyErr_Occurred()) SWIG_fail;
42141 }
42142 resultobj = SWIG_Py_Void();
42143 return resultobj;
42144 fail:
42145 return NULL;
42146 }
42147
42148
42149 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42150 PyObject *resultobj = 0;
42151 wxMenu *arg1 = (wxMenu *) 0 ;
42152 bool result;
42153 void *argp1 = 0 ;
42154 int res1 = 0 ;
42155 PyObject *swig_obj[1] ;
42156
42157 if (!args) SWIG_fail;
42158 swig_obj[0] = args;
42159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42160 if (!SWIG_IsOK(res1)) {
42161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
42162 }
42163 arg1 = reinterpret_cast< wxMenu * >(argp1);
42164 {
42165 PyThreadState* __tstate = wxPyBeginAllowThreads();
42166 result = (bool)((wxMenu const *)arg1)->IsAttached();
42167 wxPyEndAllowThreads(__tstate);
42168 if (PyErr_Occurred()) SWIG_fail;
42169 }
42170 {
42171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42172 }
42173 return resultobj;
42174 fail:
42175 return NULL;
42176 }
42177
42178
42179 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42180 PyObject *resultobj = 0;
42181 wxMenu *arg1 = (wxMenu *) 0 ;
42182 wxMenu *arg2 = (wxMenu *) 0 ;
42183 void *argp1 = 0 ;
42184 int res1 = 0 ;
42185 void *argp2 = 0 ;
42186 int res2 = 0 ;
42187 PyObject * obj0 = 0 ;
42188 PyObject * obj1 = 0 ;
42189 char * kwnames[] = {
42190 (char *) "self",(char *) "parent", NULL
42191 };
42192
42193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
42194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42195 if (!SWIG_IsOK(res1)) {
42196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
42197 }
42198 arg1 = reinterpret_cast< wxMenu * >(argp1);
42199 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42200 if (!SWIG_IsOK(res2)) {
42201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
42202 }
42203 arg2 = reinterpret_cast< wxMenu * >(argp2);
42204 {
42205 PyThreadState* __tstate = wxPyBeginAllowThreads();
42206 (arg1)->SetParent(arg2);
42207 wxPyEndAllowThreads(__tstate);
42208 if (PyErr_Occurred()) SWIG_fail;
42209 }
42210 resultobj = SWIG_Py_Void();
42211 return resultobj;
42212 fail:
42213 return NULL;
42214 }
42215
42216
42217 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42218 PyObject *resultobj = 0;
42219 wxMenu *arg1 = (wxMenu *) 0 ;
42220 wxMenu *result = 0 ;
42221 void *argp1 = 0 ;
42222 int res1 = 0 ;
42223 PyObject *swig_obj[1] ;
42224
42225 if (!args) SWIG_fail;
42226 swig_obj[0] = args;
42227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42228 if (!SWIG_IsOK(res1)) {
42229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
42230 }
42231 arg1 = reinterpret_cast< wxMenu * >(argp1);
42232 {
42233 PyThreadState* __tstate = wxPyBeginAllowThreads();
42234 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
42235 wxPyEndAllowThreads(__tstate);
42236 if (PyErr_Occurred()) SWIG_fail;
42237 }
42238 {
42239 resultobj = wxPyMake_wxObject(result, 0);
42240 }
42241 return resultobj;
42242 fail:
42243 return NULL;
42244 }
42245
42246
42247 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42248 PyObject *obj;
42249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42250 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
42251 return SWIG_Py_Void();
42252 }
42253
42254 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42255 return SWIG_Python_InitShadowInstance(args);
42256 }
42257
42258 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42259 PyObject *resultobj = 0;
42260 long arg1 = (long) 0 ;
42261 wxMenuBar *result = 0 ;
42262 long val1 ;
42263 int ecode1 = 0 ;
42264 PyObject * obj0 = 0 ;
42265 char * kwnames[] = {
42266 (char *) "style", NULL
42267 };
42268
42269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
42270 if (obj0) {
42271 ecode1 = SWIG_AsVal_long(obj0, &val1);
42272 if (!SWIG_IsOK(ecode1)) {
42273 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
42274 }
42275 arg1 = static_cast< long >(val1);
42276 }
42277 {
42278 if (!wxPyCheckForApp()) SWIG_fail;
42279 PyThreadState* __tstate = wxPyBeginAllowThreads();
42280 result = (wxMenuBar *)new wxMenuBar(arg1);
42281 wxPyEndAllowThreads(__tstate);
42282 if (PyErr_Occurred()) SWIG_fail;
42283 }
42284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
42285 return resultobj;
42286 fail:
42287 return NULL;
42288 }
42289
42290
42291 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42292 PyObject *resultobj = 0;
42293 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42294 wxMenu *arg2 = (wxMenu *) 0 ;
42295 wxString *arg3 = 0 ;
42296 bool result;
42297 void *argp1 = 0 ;
42298 int res1 = 0 ;
42299 void *argp2 = 0 ;
42300 int res2 = 0 ;
42301 bool temp3 = false ;
42302 PyObject * obj0 = 0 ;
42303 PyObject * obj1 = 0 ;
42304 PyObject * obj2 = 0 ;
42305 char * kwnames[] = {
42306 (char *) "self",(char *) "menu",(char *) "title", NULL
42307 };
42308
42309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42311 if (!SWIG_IsOK(res1)) {
42312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42313 }
42314 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42315 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42316 if (!SWIG_IsOK(res2)) {
42317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
42318 }
42319 arg2 = reinterpret_cast< wxMenu * >(argp2);
42320 {
42321 arg3 = wxString_in_helper(obj2);
42322 if (arg3 == NULL) SWIG_fail;
42323 temp3 = true;
42324 }
42325 {
42326 PyThreadState* __tstate = wxPyBeginAllowThreads();
42327 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
42328 wxPyEndAllowThreads(__tstate);
42329 if (PyErr_Occurred()) SWIG_fail;
42330 }
42331 {
42332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42333 }
42334 {
42335 if (temp3)
42336 delete arg3;
42337 }
42338 return resultobj;
42339 fail:
42340 {
42341 if (temp3)
42342 delete arg3;
42343 }
42344 return NULL;
42345 }
42346
42347
42348 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42349 PyObject *resultobj = 0;
42350 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42351 size_t arg2 ;
42352 wxMenu *arg3 = (wxMenu *) 0 ;
42353 wxString *arg4 = 0 ;
42354 bool result;
42355 void *argp1 = 0 ;
42356 int res1 = 0 ;
42357 size_t val2 ;
42358 int ecode2 = 0 ;
42359 void *argp3 = 0 ;
42360 int res3 = 0 ;
42361 bool temp4 = false ;
42362 PyObject * obj0 = 0 ;
42363 PyObject * obj1 = 0 ;
42364 PyObject * obj2 = 0 ;
42365 PyObject * obj3 = 0 ;
42366 char * kwnames[] = {
42367 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42368 };
42369
42370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42372 if (!SWIG_IsOK(res1)) {
42373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42374 }
42375 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42376 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42377 if (!SWIG_IsOK(ecode2)) {
42378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
42379 }
42380 arg2 = static_cast< size_t >(val2);
42381 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42382 if (!SWIG_IsOK(res3)) {
42383 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
42384 }
42385 arg3 = reinterpret_cast< wxMenu * >(argp3);
42386 {
42387 arg4 = wxString_in_helper(obj3);
42388 if (arg4 == NULL) SWIG_fail;
42389 temp4 = true;
42390 }
42391 {
42392 PyThreadState* __tstate = wxPyBeginAllowThreads();
42393 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
42394 wxPyEndAllowThreads(__tstate);
42395 if (PyErr_Occurred()) SWIG_fail;
42396 }
42397 {
42398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42399 }
42400 {
42401 if (temp4)
42402 delete arg4;
42403 }
42404 return resultobj;
42405 fail:
42406 {
42407 if (temp4)
42408 delete arg4;
42409 }
42410 return NULL;
42411 }
42412
42413
42414 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42415 PyObject *resultobj = 0;
42416 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42417 size_t result;
42418 void *argp1 = 0 ;
42419 int res1 = 0 ;
42420 PyObject *swig_obj[1] ;
42421
42422 if (!args) SWIG_fail;
42423 swig_obj[0] = args;
42424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42425 if (!SWIG_IsOK(res1)) {
42426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42427 }
42428 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42429 {
42430 PyThreadState* __tstate = wxPyBeginAllowThreads();
42431 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
42432 wxPyEndAllowThreads(__tstate);
42433 if (PyErr_Occurred()) SWIG_fail;
42434 }
42435 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
42436 return resultobj;
42437 fail:
42438 return NULL;
42439 }
42440
42441
42442 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42443 PyObject *resultobj = 0;
42444 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42445 size_t arg2 ;
42446 wxMenu *result = 0 ;
42447 void *argp1 = 0 ;
42448 int res1 = 0 ;
42449 size_t val2 ;
42450 int ecode2 = 0 ;
42451 PyObject * obj0 = 0 ;
42452 PyObject * obj1 = 0 ;
42453 char * kwnames[] = {
42454 (char *) "self",(char *) "pos", NULL
42455 };
42456
42457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42459 if (!SWIG_IsOK(res1)) {
42460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42461 }
42462 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42463 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42464 if (!SWIG_IsOK(ecode2)) {
42465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
42466 }
42467 arg2 = static_cast< size_t >(val2);
42468 {
42469 PyThreadState* __tstate = wxPyBeginAllowThreads();
42470 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
42471 wxPyEndAllowThreads(__tstate);
42472 if (PyErr_Occurred()) SWIG_fail;
42473 }
42474 {
42475 resultobj = wxPyMake_wxObject(result, 0);
42476 }
42477 return resultobj;
42478 fail:
42479 return NULL;
42480 }
42481
42482
42483 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42484 PyObject *resultobj = 0;
42485 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42486 size_t arg2 ;
42487 wxMenu *arg3 = (wxMenu *) 0 ;
42488 wxString *arg4 = 0 ;
42489 wxMenu *result = 0 ;
42490 void *argp1 = 0 ;
42491 int res1 = 0 ;
42492 size_t val2 ;
42493 int ecode2 = 0 ;
42494 void *argp3 = 0 ;
42495 int res3 = 0 ;
42496 bool temp4 = false ;
42497 PyObject * obj0 = 0 ;
42498 PyObject * obj1 = 0 ;
42499 PyObject * obj2 = 0 ;
42500 PyObject * obj3 = 0 ;
42501 char * kwnames[] = {
42502 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42503 };
42504
42505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42507 if (!SWIG_IsOK(res1)) {
42508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42509 }
42510 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42511 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42512 if (!SWIG_IsOK(ecode2)) {
42513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
42514 }
42515 arg2 = static_cast< size_t >(val2);
42516 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42517 if (!SWIG_IsOK(res3)) {
42518 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
42519 }
42520 arg3 = reinterpret_cast< wxMenu * >(argp3);
42521 {
42522 arg4 = wxString_in_helper(obj3);
42523 if (arg4 == NULL) SWIG_fail;
42524 temp4 = true;
42525 }
42526 {
42527 PyThreadState* __tstate = wxPyBeginAllowThreads();
42528 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
42529 wxPyEndAllowThreads(__tstate);
42530 if (PyErr_Occurred()) SWIG_fail;
42531 }
42532 {
42533 resultobj = wxPyMake_wxObject(result, 0);
42534 }
42535 {
42536 if (temp4)
42537 delete arg4;
42538 }
42539 return resultobj;
42540 fail:
42541 {
42542 if (temp4)
42543 delete arg4;
42544 }
42545 return NULL;
42546 }
42547
42548
42549 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42550 PyObject *resultobj = 0;
42551 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42552 size_t arg2 ;
42553 wxMenu *result = 0 ;
42554 void *argp1 = 0 ;
42555 int res1 = 0 ;
42556 size_t val2 ;
42557 int ecode2 = 0 ;
42558 PyObject * obj0 = 0 ;
42559 PyObject * obj1 = 0 ;
42560 char * kwnames[] = {
42561 (char *) "self",(char *) "pos", NULL
42562 };
42563
42564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
42565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42566 if (!SWIG_IsOK(res1)) {
42567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42568 }
42569 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42570 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42571 if (!SWIG_IsOK(ecode2)) {
42572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
42573 }
42574 arg2 = static_cast< size_t >(val2);
42575 {
42576 PyThreadState* __tstate = wxPyBeginAllowThreads();
42577 result = (wxMenu *)(arg1)->Remove(arg2);
42578 wxPyEndAllowThreads(__tstate);
42579 if (PyErr_Occurred()) SWIG_fail;
42580 }
42581 {
42582 resultobj = wxPyMake_wxObject(result, 0);
42583 }
42584 return resultobj;
42585 fail:
42586 return NULL;
42587 }
42588
42589
42590 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42591 PyObject *resultobj = 0;
42592 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42593 size_t arg2 ;
42594 bool arg3 ;
42595 void *argp1 = 0 ;
42596 int res1 = 0 ;
42597 size_t val2 ;
42598 int ecode2 = 0 ;
42599 bool val3 ;
42600 int ecode3 = 0 ;
42601 PyObject * obj0 = 0 ;
42602 PyObject * obj1 = 0 ;
42603 PyObject * obj2 = 0 ;
42604 char * kwnames[] = {
42605 (char *) "self",(char *) "pos",(char *) "enable", NULL
42606 };
42607
42608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42610 if (!SWIG_IsOK(res1)) {
42611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42612 }
42613 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42614 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42615 if (!SWIG_IsOK(ecode2)) {
42616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42617 }
42618 arg2 = static_cast< size_t >(val2);
42619 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42620 if (!SWIG_IsOK(ecode3)) {
42621 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42622 }
42623 arg3 = static_cast< bool >(val3);
42624 {
42625 PyThreadState* __tstate = wxPyBeginAllowThreads();
42626 (arg1)->EnableTop(arg2,arg3);
42627 wxPyEndAllowThreads(__tstate);
42628 if (PyErr_Occurred()) SWIG_fail;
42629 }
42630 resultobj = SWIG_Py_Void();
42631 return resultobj;
42632 fail:
42633 return NULL;
42634 }
42635
42636
42637 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42638 PyObject *resultobj = 0;
42639 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42640 size_t arg2 ;
42641 bool result;
42642 void *argp1 = 0 ;
42643 int res1 = 0 ;
42644 size_t val2 ;
42645 int ecode2 = 0 ;
42646 PyObject * obj0 = 0 ;
42647 PyObject * obj1 = 0 ;
42648 char * kwnames[] = {
42649 (char *) "self",(char *) "pos", NULL
42650 };
42651
42652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42654 if (!SWIG_IsOK(res1)) {
42655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42656 }
42657 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42658 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42659 if (!SWIG_IsOK(ecode2)) {
42660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42661 }
42662 arg2 = static_cast< size_t >(val2);
42663 {
42664 PyThreadState* __tstate = wxPyBeginAllowThreads();
42665 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42666 wxPyEndAllowThreads(__tstate);
42667 if (PyErr_Occurred()) SWIG_fail;
42668 }
42669 {
42670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42671 }
42672 return resultobj;
42673 fail:
42674 return NULL;
42675 }
42676
42677
42678 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42679 PyObject *resultobj = 0;
42680 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42681 size_t arg2 ;
42682 wxString *arg3 = 0 ;
42683 void *argp1 = 0 ;
42684 int res1 = 0 ;
42685 size_t val2 ;
42686 int ecode2 = 0 ;
42687 bool temp3 = false ;
42688 PyObject * obj0 = 0 ;
42689 PyObject * obj1 = 0 ;
42690 PyObject * obj2 = 0 ;
42691 char * kwnames[] = {
42692 (char *) "self",(char *) "pos",(char *) "label", NULL
42693 };
42694
42695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42697 if (!SWIG_IsOK(res1)) {
42698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42699 }
42700 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42701 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42702 if (!SWIG_IsOK(ecode2)) {
42703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42704 }
42705 arg2 = static_cast< size_t >(val2);
42706 {
42707 arg3 = wxString_in_helper(obj2);
42708 if (arg3 == NULL) SWIG_fail;
42709 temp3 = true;
42710 }
42711 {
42712 PyThreadState* __tstate = wxPyBeginAllowThreads();
42713 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42714 wxPyEndAllowThreads(__tstate);
42715 if (PyErr_Occurred()) SWIG_fail;
42716 }
42717 resultobj = SWIG_Py_Void();
42718 {
42719 if (temp3)
42720 delete arg3;
42721 }
42722 return resultobj;
42723 fail:
42724 {
42725 if (temp3)
42726 delete arg3;
42727 }
42728 return NULL;
42729 }
42730
42731
42732 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42733 PyObject *resultobj = 0;
42734 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42735 size_t arg2 ;
42736 wxString result;
42737 void *argp1 = 0 ;
42738 int res1 = 0 ;
42739 size_t val2 ;
42740 int ecode2 = 0 ;
42741 PyObject * obj0 = 0 ;
42742 PyObject * obj1 = 0 ;
42743 char * kwnames[] = {
42744 (char *) "self",(char *) "pos", NULL
42745 };
42746
42747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42749 if (!SWIG_IsOK(res1)) {
42750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42751 }
42752 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42753 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42754 if (!SWIG_IsOK(ecode2)) {
42755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42756 }
42757 arg2 = static_cast< size_t >(val2);
42758 {
42759 PyThreadState* __tstate = wxPyBeginAllowThreads();
42760 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42761 wxPyEndAllowThreads(__tstate);
42762 if (PyErr_Occurred()) SWIG_fail;
42763 }
42764 {
42765 #if wxUSE_UNICODE
42766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42767 #else
42768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42769 #endif
42770 }
42771 return resultobj;
42772 fail:
42773 return NULL;
42774 }
42775
42776
42777 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42778 PyObject *resultobj = 0;
42779 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42780 wxString *arg2 = 0 ;
42781 wxString *arg3 = 0 ;
42782 int result;
42783 void *argp1 = 0 ;
42784 int res1 = 0 ;
42785 bool temp2 = false ;
42786 bool temp3 = false ;
42787 PyObject * obj0 = 0 ;
42788 PyObject * obj1 = 0 ;
42789 PyObject * obj2 = 0 ;
42790 char * kwnames[] = {
42791 (char *) "self",(char *) "menu",(char *) "item", NULL
42792 };
42793
42794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42796 if (!SWIG_IsOK(res1)) {
42797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42798 }
42799 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42800 {
42801 arg2 = wxString_in_helper(obj1);
42802 if (arg2 == NULL) SWIG_fail;
42803 temp2 = true;
42804 }
42805 {
42806 arg3 = wxString_in_helper(obj2);
42807 if (arg3 == NULL) SWIG_fail;
42808 temp3 = true;
42809 }
42810 {
42811 PyThreadState* __tstate = wxPyBeginAllowThreads();
42812 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42813 wxPyEndAllowThreads(__tstate);
42814 if (PyErr_Occurred()) SWIG_fail;
42815 }
42816 resultobj = SWIG_From_int(static_cast< int >(result));
42817 {
42818 if (temp2)
42819 delete arg2;
42820 }
42821 {
42822 if (temp3)
42823 delete arg3;
42824 }
42825 return resultobj;
42826 fail:
42827 {
42828 if (temp2)
42829 delete arg2;
42830 }
42831 {
42832 if (temp3)
42833 delete arg3;
42834 }
42835 return NULL;
42836 }
42837
42838
42839 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42840 PyObject *resultobj = 0;
42841 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42842 int arg2 ;
42843 wxMenuItem *result = 0 ;
42844 void *argp1 = 0 ;
42845 int res1 = 0 ;
42846 int val2 ;
42847 int ecode2 = 0 ;
42848 PyObject * obj0 = 0 ;
42849 PyObject * obj1 = 0 ;
42850 char * kwnames[] = {
42851 (char *) "self",(char *) "id", NULL
42852 };
42853
42854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42856 if (!SWIG_IsOK(res1)) {
42857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42858 }
42859 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42860 ecode2 = SWIG_AsVal_int(obj1, &val2);
42861 if (!SWIG_IsOK(ecode2)) {
42862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42863 }
42864 arg2 = static_cast< int >(val2);
42865 {
42866 PyThreadState* __tstate = wxPyBeginAllowThreads();
42867 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42868 wxPyEndAllowThreads(__tstate);
42869 if (PyErr_Occurred()) SWIG_fail;
42870 }
42871 {
42872 resultobj = wxPyMake_wxObject(result, (bool)0);
42873 }
42874 return resultobj;
42875 fail:
42876 return NULL;
42877 }
42878
42879
42880 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42881 PyObject *resultobj = 0;
42882 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42883 wxString *arg2 = 0 ;
42884 int result;
42885 void *argp1 = 0 ;
42886 int res1 = 0 ;
42887 bool temp2 = false ;
42888 PyObject * obj0 = 0 ;
42889 PyObject * obj1 = 0 ;
42890 char * kwnames[] = {
42891 (char *) "self",(char *) "title", NULL
42892 };
42893
42894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42896 if (!SWIG_IsOK(res1)) {
42897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42898 }
42899 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42900 {
42901 arg2 = wxString_in_helper(obj1);
42902 if (arg2 == NULL) SWIG_fail;
42903 temp2 = true;
42904 }
42905 {
42906 PyThreadState* __tstate = wxPyBeginAllowThreads();
42907 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42908 wxPyEndAllowThreads(__tstate);
42909 if (PyErr_Occurred()) SWIG_fail;
42910 }
42911 resultobj = SWIG_From_int(static_cast< int >(result));
42912 {
42913 if (temp2)
42914 delete arg2;
42915 }
42916 return resultobj;
42917 fail:
42918 {
42919 if (temp2)
42920 delete arg2;
42921 }
42922 return NULL;
42923 }
42924
42925
42926 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42927 PyObject *resultobj = 0;
42928 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42929 int arg2 ;
42930 bool arg3 ;
42931 void *argp1 = 0 ;
42932 int res1 = 0 ;
42933 int val2 ;
42934 int ecode2 = 0 ;
42935 bool val3 ;
42936 int ecode3 = 0 ;
42937 PyObject * obj0 = 0 ;
42938 PyObject * obj1 = 0 ;
42939 PyObject * obj2 = 0 ;
42940 char * kwnames[] = {
42941 (char *) "self",(char *) "id",(char *) "enable", NULL
42942 };
42943
42944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42946 if (!SWIG_IsOK(res1)) {
42947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42948 }
42949 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42950 ecode2 = SWIG_AsVal_int(obj1, &val2);
42951 if (!SWIG_IsOK(ecode2)) {
42952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42953 }
42954 arg2 = static_cast< int >(val2);
42955 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42956 if (!SWIG_IsOK(ecode3)) {
42957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42958 }
42959 arg3 = static_cast< bool >(val3);
42960 {
42961 PyThreadState* __tstate = wxPyBeginAllowThreads();
42962 (arg1)->Enable(arg2,arg3);
42963 wxPyEndAllowThreads(__tstate);
42964 if (PyErr_Occurred()) SWIG_fail;
42965 }
42966 resultobj = SWIG_Py_Void();
42967 return resultobj;
42968 fail:
42969 return NULL;
42970 }
42971
42972
42973 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42974 PyObject *resultobj = 0;
42975 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42976 int arg2 ;
42977 bool arg3 ;
42978 void *argp1 = 0 ;
42979 int res1 = 0 ;
42980 int val2 ;
42981 int ecode2 = 0 ;
42982 bool val3 ;
42983 int ecode3 = 0 ;
42984 PyObject * obj0 = 0 ;
42985 PyObject * obj1 = 0 ;
42986 PyObject * obj2 = 0 ;
42987 char * kwnames[] = {
42988 (char *) "self",(char *) "id",(char *) "check", NULL
42989 };
42990
42991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42993 if (!SWIG_IsOK(res1)) {
42994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42995 }
42996 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42997 ecode2 = SWIG_AsVal_int(obj1, &val2);
42998 if (!SWIG_IsOK(ecode2)) {
42999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
43000 }
43001 arg2 = static_cast< int >(val2);
43002 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43003 if (!SWIG_IsOK(ecode3)) {
43004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
43005 }
43006 arg3 = static_cast< bool >(val3);
43007 {
43008 PyThreadState* __tstate = wxPyBeginAllowThreads();
43009 (arg1)->Check(arg2,arg3);
43010 wxPyEndAllowThreads(__tstate);
43011 if (PyErr_Occurred()) SWIG_fail;
43012 }
43013 resultobj = SWIG_Py_Void();
43014 return resultobj;
43015 fail:
43016 return NULL;
43017 }
43018
43019
43020 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43021 PyObject *resultobj = 0;
43022 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43023 int arg2 ;
43024 bool result;
43025 void *argp1 = 0 ;
43026 int res1 = 0 ;
43027 int val2 ;
43028 int ecode2 = 0 ;
43029 PyObject * obj0 = 0 ;
43030 PyObject * obj1 = 0 ;
43031 char * kwnames[] = {
43032 (char *) "self",(char *) "id", NULL
43033 };
43034
43035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43037 if (!SWIG_IsOK(res1)) {
43038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43039 }
43040 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43041 ecode2 = SWIG_AsVal_int(obj1, &val2);
43042 if (!SWIG_IsOK(ecode2)) {
43043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
43044 }
43045 arg2 = static_cast< int >(val2);
43046 {
43047 PyThreadState* __tstate = wxPyBeginAllowThreads();
43048 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
43049 wxPyEndAllowThreads(__tstate);
43050 if (PyErr_Occurred()) SWIG_fail;
43051 }
43052 {
43053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43054 }
43055 return resultobj;
43056 fail:
43057 return NULL;
43058 }
43059
43060
43061 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43062 PyObject *resultobj = 0;
43063 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43064 int arg2 ;
43065 bool result;
43066 void *argp1 = 0 ;
43067 int res1 = 0 ;
43068 int val2 ;
43069 int ecode2 = 0 ;
43070 PyObject * obj0 = 0 ;
43071 PyObject * obj1 = 0 ;
43072 char * kwnames[] = {
43073 (char *) "self",(char *) "id", NULL
43074 };
43075
43076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43078 if (!SWIG_IsOK(res1)) {
43079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43080 }
43081 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43082 ecode2 = SWIG_AsVal_int(obj1, &val2);
43083 if (!SWIG_IsOK(ecode2)) {
43084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43085 }
43086 arg2 = static_cast< int >(val2);
43087 {
43088 PyThreadState* __tstate = wxPyBeginAllowThreads();
43089 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
43090 wxPyEndAllowThreads(__tstate);
43091 if (PyErr_Occurred()) SWIG_fail;
43092 }
43093 {
43094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43095 }
43096 return resultobj;
43097 fail:
43098 return NULL;
43099 }
43100
43101
43102 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43103 PyObject *resultobj = 0;
43104 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43105 int arg2 ;
43106 wxString *arg3 = 0 ;
43107 void *argp1 = 0 ;
43108 int res1 = 0 ;
43109 int val2 ;
43110 int ecode2 = 0 ;
43111 bool temp3 = false ;
43112 PyObject * obj0 = 0 ;
43113 PyObject * obj1 = 0 ;
43114 PyObject * obj2 = 0 ;
43115 char * kwnames[] = {
43116 (char *) "self",(char *) "id",(char *) "label", NULL
43117 };
43118
43119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43121 if (!SWIG_IsOK(res1)) {
43122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43123 }
43124 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43125 ecode2 = SWIG_AsVal_int(obj1, &val2);
43126 if (!SWIG_IsOK(ecode2)) {
43127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
43128 }
43129 arg2 = static_cast< int >(val2);
43130 {
43131 arg3 = wxString_in_helper(obj2);
43132 if (arg3 == NULL) SWIG_fail;
43133 temp3 = true;
43134 }
43135 {
43136 PyThreadState* __tstate = wxPyBeginAllowThreads();
43137 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43138 wxPyEndAllowThreads(__tstate);
43139 if (PyErr_Occurred()) SWIG_fail;
43140 }
43141 resultobj = SWIG_Py_Void();
43142 {
43143 if (temp3)
43144 delete arg3;
43145 }
43146 return resultobj;
43147 fail:
43148 {
43149 if (temp3)
43150 delete arg3;
43151 }
43152 return NULL;
43153 }
43154
43155
43156 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43157 PyObject *resultobj = 0;
43158 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43159 int arg2 ;
43160 wxString result;
43161 void *argp1 = 0 ;
43162 int res1 = 0 ;
43163 int val2 ;
43164 int ecode2 = 0 ;
43165 PyObject * obj0 = 0 ;
43166 PyObject * obj1 = 0 ;
43167 char * kwnames[] = {
43168 (char *) "self",(char *) "id", NULL
43169 };
43170
43171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43173 if (!SWIG_IsOK(res1)) {
43174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43175 }
43176 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43177 ecode2 = SWIG_AsVal_int(obj1, &val2);
43178 if (!SWIG_IsOK(ecode2)) {
43179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
43180 }
43181 arg2 = static_cast< int >(val2);
43182 {
43183 PyThreadState* __tstate = wxPyBeginAllowThreads();
43184 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
43185 wxPyEndAllowThreads(__tstate);
43186 if (PyErr_Occurred()) SWIG_fail;
43187 }
43188 {
43189 #if wxUSE_UNICODE
43190 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43191 #else
43192 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43193 #endif
43194 }
43195 return resultobj;
43196 fail:
43197 return NULL;
43198 }
43199
43200
43201 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43202 PyObject *resultobj = 0;
43203 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43204 int arg2 ;
43205 wxString *arg3 = 0 ;
43206 void *argp1 = 0 ;
43207 int res1 = 0 ;
43208 int val2 ;
43209 int ecode2 = 0 ;
43210 bool temp3 = false ;
43211 PyObject * obj0 = 0 ;
43212 PyObject * obj1 = 0 ;
43213 PyObject * obj2 = 0 ;
43214 char * kwnames[] = {
43215 (char *) "self",(char *) "id",(char *) "helpString", NULL
43216 };
43217
43218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43220 if (!SWIG_IsOK(res1)) {
43221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43222 }
43223 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43224 ecode2 = SWIG_AsVal_int(obj1, &val2);
43225 if (!SWIG_IsOK(ecode2)) {
43226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43227 }
43228 arg2 = static_cast< int >(val2);
43229 {
43230 arg3 = wxString_in_helper(obj2);
43231 if (arg3 == NULL) SWIG_fail;
43232 temp3 = true;
43233 }
43234 {
43235 PyThreadState* __tstate = wxPyBeginAllowThreads();
43236 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43237 wxPyEndAllowThreads(__tstate);
43238 if (PyErr_Occurred()) SWIG_fail;
43239 }
43240 resultobj = SWIG_Py_Void();
43241 {
43242 if (temp3)
43243 delete arg3;
43244 }
43245 return resultobj;
43246 fail:
43247 {
43248 if (temp3)
43249 delete arg3;
43250 }
43251 return NULL;
43252 }
43253
43254
43255 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43256 PyObject *resultobj = 0;
43257 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43258 int arg2 ;
43259 wxString result;
43260 void *argp1 = 0 ;
43261 int res1 = 0 ;
43262 int val2 ;
43263 int ecode2 = 0 ;
43264 PyObject * obj0 = 0 ;
43265 PyObject * obj1 = 0 ;
43266 char * kwnames[] = {
43267 (char *) "self",(char *) "id", NULL
43268 };
43269
43270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43272 if (!SWIG_IsOK(res1)) {
43273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43274 }
43275 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43276 ecode2 = SWIG_AsVal_int(obj1, &val2);
43277 if (!SWIG_IsOK(ecode2)) {
43278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43279 }
43280 arg2 = static_cast< int >(val2);
43281 {
43282 PyThreadState* __tstate = wxPyBeginAllowThreads();
43283 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
43284 wxPyEndAllowThreads(__tstate);
43285 if (PyErr_Occurred()) SWIG_fail;
43286 }
43287 {
43288 #if wxUSE_UNICODE
43289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43290 #else
43291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43292 #endif
43293 }
43294 return resultobj;
43295 fail:
43296 return NULL;
43297 }
43298
43299
43300 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43301 PyObject *resultobj = 0;
43302 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43303 wxFrame *result = 0 ;
43304 void *argp1 = 0 ;
43305 int res1 = 0 ;
43306 PyObject *swig_obj[1] ;
43307
43308 if (!args) SWIG_fail;
43309 swig_obj[0] = args;
43310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43311 if (!SWIG_IsOK(res1)) {
43312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43313 }
43314 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43315 {
43316 PyThreadState* __tstate = wxPyBeginAllowThreads();
43317 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
43318 wxPyEndAllowThreads(__tstate);
43319 if (PyErr_Occurred()) SWIG_fail;
43320 }
43321 {
43322 resultobj = wxPyMake_wxObject(result, (bool)0);
43323 }
43324 return resultobj;
43325 fail:
43326 return NULL;
43327 }
43328
43329
43330 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43331 PyObject *resultobj = 0;
43332 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43333 bool result;
43334 void *argp1 = 0 ;
43335 int res1 = 0 ;
43336 PyObject *swig_obj[1] ;
43337
43338 if (!args) SWIG_fail;
43339 swig_obj[0] = args;
43340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43341 if (!SWIG_IsOK(res1)) {
43342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43343 }
43344 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43345 {
43346 PyThreadState* __tstate = wxPyBeginAllowThreads();
43347 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
43348 wxPyEndAllowThreads(__tstate);
43349 if (PyErr_Occurred()) SWIG_fail;
43350 }
43351 {
43352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43353 }
43354 return resultobj;
43355 fail:
43356 return NULL;
43357 }
43358
43359
43360 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43361 PyObject *resultobj = 0;
43362 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43363 wxFrame *arg2 = (wxFrame *) 0 ;
43364 void *argp1 = 0 ;
43365 int res1 = 0 ;
43366 void *argp2 = 0 ;
43367 int res2 = 0 ;
43368 PyObject * obj0 = 0 ;
43369 PyObject * obj1 = 0 ;
43370 char * kwnames[] = {
43371 (char *) "self",(char *) "frame", NULL
43372 };
43373
43374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
43375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43376 if (!SWIG_IsOK(res1)) {
43377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43378 }
43379 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43380 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
43381 if (!SWIG_IsOK(res2)) {
43382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
43383 }
43384 arg2 = reinterpret_cast< wxFrame * >(argp2);
43385 {
43386 PyThreadState* __tstate = wxPyBeginAllowThreads();
43387 (arg1)->Attach(arg2);
43388 wxPyEndAllowThreads(__tstate);
43389 if (PyErr_Occurred()) SWIG_fail;
43390 }
43391 resultobj = SWIG_Py_Void();
43392 return resultobj;
43393 fail:
43394 return NULL;
43395 }
43396
43397
43398 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43399 PyObject *resultobj = 0;
43400 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43401 void *argp1 = 0 ;
43402 int res1 = 0 ;
43403 PyObject *swig_obj[1] ;
43404
43405 if (!args) SWIG_fail;
43406 swig_obj[0] = args;
43407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43408 if (!SWIG_IsOK(res1)) {
43409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43410 }
43411 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43412 {
43413 PyThreadState* __tstate = wxPyBeginAllowThreads();
43414 (arg1)->Detach();
43415 wxPyEndAllowThreads(__tstate);
43416 if (PyErr_Occurred()) SWIG_fail;
43417 }
43418 resultobj = SWIG_Py_Void();
43419 return resultobj;
43420 fail:
43421 return NULL;
43422 }
43423
43424
43425 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43426 PyObject *resultobj = 0;
43427 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43428 void *argp1 = 0 ;
43429 int res1 = 0 ;
43430 PyObject *swig_obj[1] ;
43431
43432 if (!args) SWIG_fail;
43433 swig_obj[0] = args;
43434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43435 if (!SWIG_IsOK(res1)) {
43436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43437 }
43438 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43439 {
43440 PyThreadState* __tstate = wxPyBeginAllowThreads();
43441 (arg1)->UpdateMenus();
43442 wxPyEndAllowThreads(__tstate);
43443 if (PyErr_Occurred()) SWIG_fail;
43444 }
43445 resultobj = SWIG_Py_Void();
43446 return resultobj;
43447 fail:
43448 return NULL;
43449 }
43450
43451
43452 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43453 PyObject *resultobj = 0;
43454 bool arg1 ;
43455 bool val1 ;
43456 int ecode1 = 0 ;
43457 PyObject * obj0 = 0 ;
43458 char * kwnames[] = {
43459 (char *) "enable", NULL
43460 };
43461
43462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
43463 ecode1 = SWIG_AsVal_bool(obj0, &val1);
43464 if (!SWIG_IsOK(ecode1)) {
43465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
43466 }
43467 arg1 = static_cast< bool >(val1);
43468 {
43469 PyThreadState* __tstate = wxPyBeginAllowThreads();
43470 wxMenuBar::SetAutoWindowMenu(arg1);
43471 wxPyEndAllowThreads(__tstate);
43472 if (PyErr_Occurred()) SWIG_fail;
43473 }
43474 resultobj = SWIG_Py_Void();
43475 return resultobj;
43476 fail:
43477 return NULL;
43478 }
43479
43480
43481 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43482 PyObject *resultobj = 0;
43483 bool result;
43484
43485 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
43486 {
43487 PyThreadState* __tstate = wxPyBeginAllowThreads();
43488 result = (bool)wxMenuBar::GetAutoWindowMenu();
43489 wxPyEndAllowThreads(__tstate);
43490 if (PyErr_Occurred()) SWIG_fail;
43491 }
43492 {
43493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43494 }
43495 return resultobj;
43496 fail:
43497 return NULL;
43498 }
43499
43500
43501 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43502 PyObject *obj;
43503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43504 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
43505 return SWIG_Py_Void();
43506 }
43507
43508 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43509 return SWIG_Python_InitShadowInstance(args);
43510 }
43511
43512 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43513 PyObject *resultobj = 0;
43514 wxMenu *arg1 = (wxMenu *) NULL ;
43515 int arg2 = (int) wxID_ANY ;
43516 wxString const &arg3_defvalue = wxPyEmptyString ;
43517 wxString *arg3 = (wxString *) &arg3_defvalue ;
43518 wxString const &arg4_defvalue = wxPyEmptyString ;
43519 wxString *arg4 = (wxString *) &arg4_defvalue ;
43520 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43521 wxMenu *arg6 = (wxMenu *) NULL ;
43522 wxMenuItem *result = 0 ;
43523 void *argp1 = 0 ;
43524 int res1 = 0 ;
43525 int val2 ;
43526 int ecode2 = 0 ;
43527 bool temp3 = false ;
43528 bool temp4 = false ;
43529 int val5 ;
43530 int ecode5 = 0 ;
43531 void *argp6 = 0 ;
43532 int res6 = 0 ;
43533 PyObject * obj0 = 0 ;
43534 PyObject * obj1 = 0 ;
43535 PyObject * obj2 = 0 ;
43536 PyObject * obj3 = 0 ;
43537 PyObject * obj4 = 0 ;
43538 PyObject * obj5 = 0 ;
43539 char * kwnames[] = {
43540 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
43541 };
43542
43543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43544 if (obj0) {
43545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43546 if (!SWIG_IsOK(res1)) {
43547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43548 }
43549 arg1 = reinterpret_cast< wxMenu * >(argp1);
43550 }
43551 if (obj1) {
43552 ecode2 = SWIG_AsVal_int(obj1, &val2);
43553 if (!SWIG_IsOK(ecode2)) {
43554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
43555 }
43556 arg2 = static_cast< int >(val2);
43557 }
43558 if (obj2) {
43559 {
43560 arg3 = wxString_in_helper(obj2);
43561 if (arg3 == NULL) SWIG_fail;
43562 temp3 = true;
43563 }
43564 }
43565 if (obj3) {
43566 {
43567 arg4 = wxString_in_helper(obj3);
43568 if (arg4 == NULL) SWIG_fail;
43569 temp4 = true;
43570 }
43571 }
43572 if (obj4) {
43573 ecode5 = SWIG_AsVal_int(obj4, &val5);
43574 if (!SWIG_IsOK(ecode5)) {
43575 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
43576 }
43577 arg5 = static_cast< wxItemKind >(val5);
43578 }
43579 if (obj5) {
43580 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
43581 if (!SWIG_IsOK(res6)) {
43582 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43583 }
43584 arg6 = reinterpret_cast< wxMenu * >(argp6);
43585 }
43586 {
43587 PyThreadState* __tstate = wxPyBeginAllowThreads();
43588 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43589 wxPyEndAllowThreads(__tstate);
43590 if (PyErr_Occurred()) SWIG_fail;
43591 }
43592 {
43593 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
43594 }
43595 {
43596 if (temp3)
43597 delete arg3;
43598 }
43599 {
43600 if (temp4)
43601 delete arg4;
43602 }
43603 return resultobj;
43604 fail:
43605 {
43606 if (temp3)
43607 delete arg3;
43608 }
43609 {
43610 if (temp4)
43611 delete arg4;
43612 }
43613 return NULL;
43614 }
43615
43616
43617 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43618 PyObject *resultobj = 0;
43619 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43620 void *argp1 = 0 ;
43621 int res1 = 0 ;
43622 PyObject *swig_obj[1] ;
43623
43624 if (!args) SWIG_fail;
43625 swig_obj[0] = args;
43626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43627 if (!SWIG_IsOK(res1)) {
43628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43629 }
43630 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43631 {
43632 PyThreadState* __tstate = wxPyBeginAllowThreads();
43633 delete arg1;
43634
43635 wxPyEndAllowThreads(__tstate);
43636 if (PyErr_Occurred()) SWIG_fail;
43637 }
43638 resultobj = SWIG_Py_Void();
43639 return resultobj;
43640 fail:
43641 return NULL;
43642 }
43643
43644
43645 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43646 PyObject *resultobj = 0;
43647 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43648 wxMenu *result = 0 ;
43649 void *argp1 = 0 ;
43650 int res1 = 0 ;
43651 PyObject *swig_obj[1] ;
43652
43653 if (!args) SWIG_fail;
43654 swig_obj[0] = args;
43655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43656 if (!SWIG_IsOK(res1)) {
43657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43658 }
43659 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43660 {
43661 PyThreadState* __tstate = wxPyBeginAllowThreads();
43662 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43663 wxPyEndAllowThreads(__tstate);
43664 if (PyErr_Occurred()) SWIG_fail;
43665 }
43666 {
43667 resultobj = wxPyMake_wxObject(result, 0);
43668 }
43669 return resultobj;
43670 fail:
43671 return NULL;
43672 }
43673
43674
43675 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43676 PyObject *resultobj = 0;
43677 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43678 wxMenu *arg2 = (wxMenu *) 0 ;
43679 void *argp1 = 0 ;
43680 int res1 = 0 ;
43681 void *argp2 = 0 ;
43682 int res2 = 0 ;
43683 PyObject * obj0 = 0 ;
43684 PyObject * obj1 = 0 ;
43685 char * kwnames[] = {
43686 (char *) "self",(char *) "menu", NULL
43687 };
43688
43689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43691 if (!SWIG_IsOK(res1)) {
43692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43693 }
43694 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43695 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43696 if (!SWIG_IsOK(res2)) {
43697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43698 }
43699 arg2 = reinterpret_cast< wxMenu * >(argp2);
43700 {
43701 PyThreadState* __tstate = wxPyBeginAllowThreads();
43702 (arg1)->SetMenu(arg2);
43703 wxPyEndAllowThreads(__tstate);
43704 if (PyErr_Occurred()) SWIG_fail;
43705 }
43706 resultobj = SWIG_Py_Void();
43707 return resultobj;
43708 fail:
43709 return NULL;
43710 }
43711
43712
43713 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43714 PyObject *resultobj = 0;
43715 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43716 int arg2 ;
43717 void *argp1 = 0 ;
43718 int res1 = 0 ;
43719 int val2 ;
43720 int ecode2 = 0 ;
43721 PyObject * obj0 = 0 ;
43722 PyObject * obj1 = 0 ;
43723 char * kwnames[] = {
43724 (char *) "self",(char *) "id", NULL
43725 };
43726
43727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43729 if (!SWIG_IsOK(res1)) {
43730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43731 }
43732 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43733 ecode2 = SWIG_AsVal_int(obj1, &val2);
43734 if (!SWIG_IsOK(ecode2)) {
43735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43736 }
43737 arg2 = static_cast< int >(val2);
43738 {
43739 PyThreadState* __tstate = wxPyBeginAllowThreads();
43740 (arg1)->SetId(arg2);
43741 wxPyEndAllowThreads(__tstate);
43742 if (PyErr_Occurred()) SWIG_fail;
43743 }
43744 resultobj = SWIG_Py_Void();
43745 return resultobj;
43746 fail:
43747 return NULL;
43748 }
43749
43750
43751 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43752 PyObject *resultobj = 0;
43753 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43754 int result;
43755 void *argp1 = 0 ;
43756 int res1 = 0 ;
43757 PyObject *swig_obj[1] ;
43758
43759 if (!args) SWIG_fail;
43760 swig_obj[0] = args;
43761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43762 if (!SWIG_IsOK(res1)) {
43763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43764 }
43765 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43766 {
43767 PyThreadState* __tstate = wxPyBeginAllowThreads();
43768 result = (int)((wxMenuItem const *)arg1)->GetId();
43769 wxPyEndAllowThreads(__tstate);
43770 if (PyErr_Occurred()) SWIG_fail;
43771 }
43772 resultobj = SWIG_From_int(static_cast< int >(result));
43773 return resultobj;
43774 fail:
43775 return NULL;
43776 }
43777
43778
43779 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43780 PyObject *resultobj = 0;
43781 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43782 bool result;
43783 void *argp1 = 0 ;
43784 int res1 = 0 ;
43785 PyObject *swig_obj[1] ;
43786
43787 if (!args) SWIG_fail;
43788 swig_obj[0] = args;
43789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43790 if (!SWIG_IsOK(res1)) {
43791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43792 }
43793 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43794 {
43795 PyThreadState* __tstate = wxPyBeginAllowThreads();
43796 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43797 wxPyEndAllowThreads(__tstate);
43798 if (PyErr_Occurred()) SWIG_fail;
43799 }
43800 {
43801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43802 }
43803 return resultobj;
43804 fail:
43805 return NULL;
43806 }
43807
43808
43809 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43810 PyObject *resultobj = 0;
43811 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43812 wxString *arg2 = 0 ;
43813 void *argp1 = 0 ;
43814 int res1 = 0 ;
43815 bool temp2 = false ;
43816 PyObject * obj0 = 0 ;
43817 PyObject * obj1 = 0 ;
43818 char * kwnames[] = {
43819 (char *) "self",(char *) "str", NULL
43820 };
43821
43822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43824 if (!SWIG_IsOK(res1)) {
43825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43826 }
43827 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43828 {
43829 arg2 = wxString_in_helper(obj1);
43830 if (arg2 == NULL) SWIG_fail;
43831 temp2 = true;
43832 }
43833 {
43834 PyThreadState* __tstate = wxPyBeginAllowThreads();
43835 (arg1)->SetText((wxString const &)*arg2);
43836 wxPyEndAllowThreads(__tstate);
43837 if (PyErr_Occurred()) SWIG_fail;
43838 }
43839 resultobj = SWIG_Py_Void();
43840 {
43841 if (temp2)
43842 delete arg2;
43843 }
43844 return resultobj;
43845 fail:
43846 {
43847 if (temp2)
43848 delete arg2;
43849 }
43850 return NULL;
43851 }
43852
43853
43854 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43855 PyObject *resultobj = 0;
43856 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43857 wxString result;
43858 void *argp1 = 0 ;
43859 int res1 = 0 ;
43860 PyObject *swig_obj[1] ;
43861
43862 if (!args) SWIG_fail;
43863 swig_obj[0] = args;
43864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43865 if (!SWIG_IsOK(res1)) {
43866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43867 }
43868 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43869 {
43870 PyThreadState* __tstate = wxPyBeginAllowThreads();
43871 result = ((wxMenuItem const *)arg1)->GetLabel();
43872 wxPyEndAllowThreads(__tstate);
43873 if (PyErr_Occurred()) SWIG_fail;
43874 }
43875 {
43876 #if wxUSE_UNICODE
43877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43878 #else
43879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43880 #endif
43881 }
43882 return resultobj;
43883 fail:
43884 return NULL;
43885 }
43886
43887
43888 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43889 PyObject *resultobj = 0;
43890 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43891 wxString *result = 0 ;
43892 void *argp1 = 0 ;
43893 int res1 = 0 ;
43894 PyObject *swig_obj[1] ;
43895
43896 if (!args) SWIG_fail;
43897 swig_obj[0] = args;
43898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43899 if (!SWIG_IsOK(res1)) {
43900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43901 }
43902 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43903 {
43904 PyThreadState* __tstate = wxPyBeginAllowThreads();
43905 {
43906 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43907 result = (wxString *) &_result_ref;
43908 }
43909 wxPyEndAllowThreads(__tstate);
43910 if (PyErr_Occurred()) SWIG_fail;
43911 }
43912 {
43913 #if wxUSE_UNICODE
43914 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43915 #else
43916 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43917 #endif
43918 }
43919 return resultobj;
43920 fail:
43921 return NULL;
43922 }
43923
43924
43925 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43926 PyObject *resultobj = 0;
43927 wxString *arg1 = 0 ;
43928 wxString result;
43929 bool temp1 = false ;
43930 PyObject * obj0 = 0 ;
43931 char * kwnames[] = {
43932 (char *) "text", NULL
43933 };
43934
43935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43936 {
43937 arg1 = wxString_in_helper(obj0);
43938 if (arg1 == NULL) SWIG_fail;
43939 temp1 = true;
43940 }
43941 {
43942 PyThreadState* __tstate = wxPyBeginAllowThreads();
43943 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43944 wxPyEndAllowThreads(__tstate);
43945 if (PyErr_Occurred()) SWIG_fail;
43946 }
43947 {
43948 #if wxUSE_UNICODE
43949 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43950 #else
43951 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43952 #endif
43953 }
43954 {
43955 if (temp1)
43956 delete arg1;
43957 }
43958 return resultobj;
43959 fail:
43960 {
43961 if (temp1)
43962 delete arg1;
43963 }
43964 return NULL;
43965 }
43966
43967
43968 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43969 PyObject *resultobj = 0;
43970 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43971 wxItemKind result;
43972 void *argp1 = 0 ;
43973 int res1 = 0 ;
43974 PyObject *swig_obj[1] ;
43975
43976 if (!args) SWIG_fail;
43977 swig_obj[0] = args;
43978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43979 if (!SWIG_IsOK(res1)) {
43980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43981 }
43982 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43983 {
43984 PyThreadState* __tstate = wxPyBeginAllowThreads();
43985 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43986 wxPyEndAllowThreads(__tstate);
43987 if (PyErr_Occurred()) SWIG_fail;
43988 }
43989 resultobj = SWIG_From_int(static_cast< int >(result));
43990 return resultobj;
43991 fail:
43992 return NULL;
43993 }
43994
43995
43996 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43997 PyObject *resultobj = 0;
43998 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43999 wxItemKind arg2 ;
44000 void *argp1 = 0 ;
44001 int res1 = 0 ;
44002 int val2 ;
44003 int ecode2 = 0 ;
44004 PyObject * obj0 = 0 ;
44005 PyObject * obj1 = 0 ;
44006 char * kwnames[] = {
44007 (char *) "self",(char *) "kind", NULL
44008 };
44009
44010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
44011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44012 if (!SWIG_IsOK(res1)) {
44013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44014 }
44015 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44016 ecode2 = SWIG_AsVal_int(obj1, &val2);
44017 if (!SWIG_IsOK(ecode2)) {
44018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
44019 }
44020 arg2 = static_cast< wxItemKind >(val2);
44021 {
44022 PyThreadState* __tstate = wxPyBeginAllowThreads();
44023 (arg1)->SetKind(arg2);
44024 wxPyEndAllowThreads(__tstate);
44025 if (PyErr_Occurred()) SWIG_fail;
44026 }
44027 resultobj = SWIG_Py_Void();
44028 return resultobj;
44029 fail:
44030 return NULL;
44031 }
44032
44033
44034 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44035 PyObject *resultobj = 0;
44036 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44037 bool arg2 ;
44038 void *argp1 = 0 ;
44039 int res1 = 0 ;
44040 bool val2 ;
44041 int ecode2 = 0 ;
44042 PyObject * obj0 = 0 ;
44043 PyObject * obj1 = 0 ;
44044 char * kwnames[] = {
44045 (char *) "self",(char *) "checkable", NULL
44046 };
44047
44048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
44049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44050 if (!SWIG_IsOK(res1)) {
44051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44052 }
44053 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44054 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44055 if (!SWIG_IsOK(ecode2)) {
44056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
44057 }
44058 arg2 = static_cast< bool >(val2);
44059 {
44060 PyThreadState* __tstate = wxPyBeginAllowThreads();
44061 (arg1)->SetCheckable(arg2);
44062 wxPyEndAllowThreads(__tstate);
44063 if (PyErr_Occurred()) SWIG_fail;
44064 }
44065 resultobj = SWIG_Py_Void();
44066 return resultobj;
44067 fail:
44068 return NULL;
44069 }
44070
44071
44072 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44073 PyObject *resultobj = 0;
44074 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44075 bool result;
44076 void *argp1 = 0 ;
44077 int res1 = 0 ;
44078 PyObject *swig_obj[1] ;
44079
44080 if (!args) SWIG_fail;
44081 swig_obj[0] = args;
44082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44083 if (!SWIG_IsOK(res1)) {
44084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44085 }
44086 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44087 {
44088 PyThreadState* __tstate = wxPyBeginAllowThreads();
44089 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
44090 wxPyEndAllowThreads(__tstate);
44091 if (PyErr_Occurred()) SWIG_fail;
44092 }
44093 {
44094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44095 }
44096 return resultobj;
44097 fail:
44098 return NULL;
44099 }
44100
44101
44102 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44103 PyObject *resultobj = 0;
44104 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44105 bool result;
44106 void *argp1 = 0 ;
44107 int res1 = 0 ;
44108 PyObject *swig_obj[1] ;
44109
44110 if (!args) SWIG_fail;
44111 swig_obj[0] = args;
44112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44113 if (!SWIG_IsOK(res1)) {
44114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44115 }
44116 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44117 {
44118 PyThreadState* __tstate = wxPyBeginAllowThreads();
44119 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
44120 wxPyEndAllowThreads(__tstate);
44121 if (PyErr_Occurred()) SWIG_fail;
44122 }
44123 {
44124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44125 }
44126 return resultobj;
44127 fail:
44128 return NULL;
44129 }
44130
44131
44132 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44133 PyObject *resultobj = 0;
44134 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44135 wxMenu *arg2 = (wxMenu *) 0 ;
44136 void *argp1 = 0 ;
44137 int res1 = 0 ;
44138 void *argp2 = 0 ;
44139 int res2 = 0 ;
44140 PyObject * obj0 = 0 ;
44141 PyObject * obj1 = 0 ;
44142 char * kwnames[] = {
44143 (char *) "self",(char *) "menu", NULL
44144 };
44145
44146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44148 if (!SWIG_IsOK(res1)) {
44149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44150 }
44151 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44152 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44153 if (!SWIG_IsOK(res2)) {
44154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
44155 }
44156 arg2 = reinterpret_cast< wxMenu * >(argp2);
44157 {
44158 PyThreadState* __tstate = wxPyBeginAllowThreads();
44159 (arg1)->SetSubMenu(arg2);
44160 wxPyEndAllowThreads(__tstate);
44161 if (PyErr_Occurred()) SWIG_fail;
44162 }
44163 resultobj = SWIG_Py_Void();
44164 return resultobj;
44165 fail:
44166 return NULL;
44167 }
44168
44169
44170 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44171 PyObject *resultobj = 0;
44172 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44173 wxMenu *result = 0 ;
44174 void *argp1 = 0 ;
44175 int res1 = 0 ;
44176 PyObject *swig_obj[1] ;
44177
44178 if (!args) SWIG_fail;
44179 swig_obj[0] = args;
44180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44181 if (!SWIG_IsOK(res1)) {
44182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44183 }
44184 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44185 {
44186 PyThreadState* __tstate = wxPyBeginAllowThreads();
44187 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
44188 wxPyEndAllowThreads(__tstate);
44189 if (PyErr_Occurred()) SWIG_fail;
44190 }
44191 {
44192 resultobj = wxPyMake_wxObject(result, 0);
44193 }
44194 return resultobj;
44195 fail:
44196 return NULL;
44197 }
44198
44199
44200 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44201 PyObject *resultobj = 0;
44202 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44203 bool arg2 = (bool) true ;
44204 void *argp1 = 0 ;
44205 int res1 = 0 ;
44206 bool val2 ;
44207 int ecode2 = 0 ;
44208 PyObject * obj0 = 0 ;
44209 PyObject * obj1 = 0 ;
44210 char * kwnames[] = {
44211 (char *) "self",(char *) "enable", NULL
44212 };
44213
44214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
44215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44216 if (!SWIG_IsOK(res1)) {
44217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44218 }
44219 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44220 if (obj1) {
44221 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44222 if (!SWIG_IsOK(ecode2)) {
44223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
44224 }
44225 arg2 = static_cast< bool >(val2);
44226 }
44227 {
44228 PyThreadState* __tstate = wxPyBeginAllowThreads();
44229 (arg1)->Enable(arg2);
44230 wxPyEndAllowThreads(__tstate);
44231 if (PyErr_Occurred()) SWIG_fail;
44232 }
44233 resultobj = SWIG_Py_Void();
44234 return resultobj;
44235 fail:
44236 return NULL;
44237 }
44238
44239
44240 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44241 PyObject *resultobj = 0;
44242 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44243 bool result;
44244 void *argp1 = 0 ;
44245 int res1 = 0 ;
44246 PyObject *swig_obj[1] ;
44247
44248 if (!args) SWIG_fail;
44249 swig_obj[0] = args;
44250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44251 if (!SWIG_IsOK(res1)) {
44252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44253 }
44254 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44255 {
44256 PyThreadState* __tstate = wxPyBeginAllowThreads();
44257 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
44258 wxPyEndAllowThreads(__tstate);
44259 if (PyErr_Occurred()) SWIG_fail;
44260 }
44261 {
44262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44263 }
44264 return resultobj;
44265 fail:
44266 return NULL;
44267 }
44268
44269
44270 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44271 PyObject *resultobj = 0;
44272 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44273 bool arg2 = (bool) true ;
44274 void *argp1 = 0 ;
44275 int res1 = 0 ;
44276 bool val2 ;
44277 int ecode2 = 0 ;
44278 PyObject * obj0 = 0 ;
44279 PyObject * obj1 = 0 ;
44280 char * kwnames[] = {
44281 (char *) "self",(char *) "check", NULL
44282 };
44283
44284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
44285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44286 if (!SWIG_IsOK(res1)) {
44287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44288 }
44289 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44290 if (obj1) {
44291 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44292 if (!SWIG_IsOK(ecode2)) {
44293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
44294 }
44295 arg2 = static_cast< bool >(val2);
44296 }
44297 {
44298 PyThreadState* __tstate = wxPyBeginAllowThreads();
44299 (arg1)->Check(arg2);
44300 wxPyEndAllowThreads(__tstate);
44301 if (PyErr_Occurred()) SWIG_fail;
44302 }
44303 resultobj = SWIG_Py_Void();
44304 return resultobj;
44305 fail:
44306 return NULL;
44307 }
44308
44309
44310 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44311 PyObject *resultobj = 0;
44312 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44313 bool result;
44314 void *argp1 = 0 ;
44315 int res1 = 0 ;
44316 PyObject *swig_obj[1] ;
44317
44318 if (!args) SWIG_fail;
44319 swig_obj[0] = args;
44320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44321 if (!SWIG_IsOK(res1)) {
44322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44323 }
44324 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44325 {
44326 PyThreadState* __tstate = wxPyBeginAllowThreads();
44327 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
44328 wxPyEndAllowThreads(__tstate);
44329 if (PyErr_Occurred()) SWIG_fail;
44330 }
44331 {
44332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44333 }
44334 return resultobj;
44335 fail:
44336 return NULL;
44337 }
44338
44339
44340 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44341 PyObject *resultobj = 0;
44342 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44343 void *argp1 = 0 ;
44344 int res1 = 0 ;
44345 PyObject *swig_obj[1] ;
44346
44347 if (!args) SWIG_fail;
44348 swig_obj[0] = args;
44349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44350 if (!SWIG_IsOK(res1)) {
44351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44352 }
44353 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44354 {
44355 PyThreadState* __tstate = wxPyBeginAllowThreads();
44356 (arg1)->Toggle();
44357 wxPyEndAllowThreads(__tstate);
44358 if (PyErr_Occurred()) SWIG_fail;
44359 }
44360 resultobj = SWIG_Py_Void();
44361 return resultobj;
44362 fail:
44363 return NULL;
44364 }
44365
44366
44367 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44368 PyObject *resultobj = 0;
44369 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44370 wxString *arg2 = 0 ;
44371 void *argp1 = 0 ;
44372 int res1 = 0 ;
44373 bool temp2 = false ;
44374 PyObject * obj0 = 0 ;
44375 PyObject * obj1 = 0 ;
44376 char * kwnames[] = {
44377 (char *) "self",(char *) "str", NULL
44378 };
44379
44380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
44381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44382 if (!SWIG_IsOK(res1)) {
44383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44384 }
44385 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44386 {
44387 arg2 = wxString_in_helper(obj1);
44388 if (arg2 == NULL) SWIG_fail;
44389 temp2 = true;
44390 }
44391 {
44392 PyThreadState* __tstate = wxPyBeginAllowThreads();
44393 (arg1)->SetHelp((wxString const &)*arg2);
44394 wxPyEndAllowThreads(__tstate);
44395 if (PyErr_Occurred()) SWIG_fail;
44396 }
44397 resultobj = SWIG_Py_Void();
44398 {
44399 if (temp2)
44400 delete arg2;
44401 }
44402 return resultobj;
44403 fail:
44404 {
44405 if (temp2)
44406 delete arg2;
44407 }
44408 return NULL;
44409 }
44410
44411
44412 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44413 PyObject *resultobj = 0;
44414 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44415 wxString *result = 0 ;
44416 void *argp1 = 0 ;
44417 int res1 = 0 ;
44418 PyObject *swig_obj[1] ;
44419
44420 if (!args) SWIG_fail;
44421 swig_obj[0] = args;
44422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44423 if (!SWIG_IsOK(res1)) {
44424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44425 }
44426 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44427 {
44428 PyThreadState* __tstate = wxPyBeginAllowThreads();
44429 {
44430 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
44431 result = (wxString *) &_result_ref;
44432 }
44433 wxPyEndAllowThreads(__tstate);
44434 if (PyErr_Occurred()) SWIG_fail;
44435 }
44436 {
44437 #if wxUSE_UNICODE
44438 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
44439 #else
44440 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
44441 #endif
44442 }
44443 return resultobj;
44444 fail:
44445 return NULL;
44446 }
44447
44448
44449 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44450 PyObject *resultobj = 0;
44451 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44452 wxAcceleratorEntry *result = 0 ;
44453 void *argp1 = 0 ;
44454 int res1 = 0 ;
44455 PyObject *swig_obj[1] ;
44456
44457 if (!args) SWIG_fail;
44458 swig_obj[0] = args;
44459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44460 if (!SWIG_IsOK(res1)) {
44461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44462 }
44463 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44464 {
44465 PyThreadState* __tstate = wxPyBeginAllowThreads();
44466 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
44467 wxPyEndAllowThreads(__tstate);
44468 if (PyErr_Occurred()) SWIG_fail;
44469 }
44470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44471 return resultobj;
44472 fail:
44473 return NULL;
44474 }
44475
44476
44477 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44478 PyObject *resultobj = 0;
44479 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44480 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
44481 void *argp1 = 0 ;
44482 int res1 = 0 ;
44483 void *argp2 = 0 ;
44484 int res2 = 0 ;
44485 PyObject * obj0 = 0 ;
44486 PyObject * obj1 = 0 ;
44487 char * kwnames[] = {
44488 (char *) "self",(char *) "accel", NULL
44489 };
44490
44491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
44492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44493 if (!SWIG_IsOK(res1)) {
44494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44495 }
44496 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44497 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44498 if (!SWIG_IsOK(res2)) {
44499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
44500 }
44501 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
44502 {
44503 PyThreadState* __tstate = wxPyBeginAllowThreads();
44504 (arg1)->SetAccel(arg2);
44505 wxPyEndAllowThreads(__tstate);
44506 if (PyErr_Occurred()) SWIG_fail;
44507 }
44508 resultobj = SWIG_Py_Void();
44509 return resultobj;
44510 fail:
44511 return NULL;
44512 }
44513
44514
44515 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44516 PyObject *resultobj = 0;
44517 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44518 wxBitmap *arg2 = 0 ;
44519 void *argp1 = 0 ;
44520 int res1 = 0 ;
44521 void *argp2 = 0 ;
44522 int res2 = 0 ;
44523 PyObject * obj0 = 0 ;
44524 PyObject * obj1 = 0 ;
44525 char * kwnames[] = {
44526 (char *) "self",(char *) "bitmap", NULL
44527 };
44528
44529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44531 if (!SWIG_IsOK(res1)) {
44532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44533 }
44534 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44535 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44536 if (!SWIG_IsOK(res2)) {
44537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44538 }
44539 if (!argp2) {
44540 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44541 }
44542 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44543 {
44544 PyThreadState* __tstate = wxPyBeginAllowThreads();
44545 (arg1)->SetBitmap((wxBitmap const &)*arg2);
44546 wxPyEndAllowThreads(__tstate);
44547 if (PyErr_Occurred()) SWIG_fail;
44548 }
44549 resultobj = SWIG_Py_Void();
44550 return resultobj;
44551 fail:
44552 return NULL;
44553 }
44554
44555
44556 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44557 PyObject *resultobj = 0;
44558 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44559 wxBitmap *result = 0 ;
44560 void *argp1 = 0 ;
44561 int res1 = 0 ;
44562 PyObject *swig_obj[1] ;
44563
44564 if (!args) SWIG_fail;
44565 swig_obj[0] = args;
44566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44567 if (!SWIG_IsOK(res1)) {
44568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44569 }
44570 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44571 {
44572 PyThreadState* __tstate = wxPyBeginAllowThreads();
44573 {
44574 wxBitmap const &_result_ref = (arg1)->GetBitmap();
44575 result = (wxBitmap *) &_result_ref;
44576 }
44577 wxPyEndAllowThreads(__tstate);
44578 if (PyErr_Occurred()) SWIG_fail;
44579 }
44580 {
44581 wxBitmap* resultptr = new wxBitmap(*result);
44582 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44583 }
44584 return resultobj;
44585 fail:
44586 return NULL;
44587 }
44588
44589
44590 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44591 PyObject *resultobj = 0;
44592 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44593 wxFont *arg2 = 0 ;
44594 void *argp1 = 0 ;
44595 int res1 = 0 ;
44596 void *argp2 = 0 ;
44597 int res2 = 0 ;
44598 PyObject * obj0 = 0 ;
44599 PyObject * obj1 = 0 ;
44600 char * kwnames[] = {
44601 (char *) "self",(char *) "font", NULL
44602 };
44603
44604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44606 if (!SWIG_IsOK(res1)) {
44607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44608 }
44609 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44610 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44611 if (!SWIG_IsOK(res2)) {
44612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44613 }
44614 if (!argp2) {
44615 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44616 }
44617 arg2 = reinterpret_cast< wxFont * >(argp2);
44618 {
44619 PyThreadState* __tstate = wxPyBeginAllowThreads();
44620 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
44621 wxPyEndAllowThreads(__tstate);
44622 if (PyErr_Occurred()) SWIG_fail;
44623 }
44624 resultobj = SWIG_Py_Void();
44625 return resultobj;
44626 fail:
44627 return NULL;
44628 }
44629
44630
44631 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44632 PyObject *resultobj = 0;
44633 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44634 wxFont result;
44635 void *argp1 = 0 ;
44636 int res1 = 0 ;
44637 PyObject *swig_obj[1] ;
44638
44639 if (!args) SWIG_fail;
44640 swig_obj[0] = args;
44641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44642 if (!SWIG_IsOK(res1)) {
44643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44644 }
44645 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44646 {
44647 PyThreadState* __tstate = wxPyBeginAllowThreads();
44648 result = wxMenuItem_GetFont(arg1);
44649 wxPyEndAllowThreads(__tstate);
44650 if (PyErr_Occurred()) SWIG_fail;
44651 }
44652 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44653 return resultobj;
44654 fail:
44655 return NULL;
44656 }
44657
44658
44659 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44660 PyObject *resultobj = 0;
44661 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44662 wxColour *arg2 = 0 ;
44663 void *argp1 = 0 ;
44664 int res1 = 0 ;
44665 wxColour temp2 ;
44666 PyObject * obj0 = 0 ;
44667 PyObject * obj1 = 0 ;
44668 char * kwnames[] = {
44669 (char *) "self",(char *) "colText", NULL
44670 };
44671
44672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44674 if (!SWIG_IsOK(res1)) {
44675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44676 }
44677 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44678 {
44679 arg2 = &temp2;
44680 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44681 }
44682 {
44683 PyThreadState* __tstate = wxPyBeginAllowThreads();
44684 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44685 wxPyEndAllowThreads(__tstate);
44686 if (PyErr_Occurred()) SWIG_fail;
44687 }
44688 resultobj = SWIG_Py_Void();
44689 return resultobj;
44690 fail:
44691 return NULL;
44692 }
44693
44694
44695 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44696 PyObject *resultobj = 0;
44697 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44698 wxColour result;
44699 void *argp1 = 0 ;
44700 int res1 = 0 ;
44701 PyObject *swig_obj[1] ;
44702
44703 if (!args) SWIG_fail;
44704 swig_obj[0] = args;
44705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44706 if (!SWIG_IsOK(res1)) {
44707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44708 }
44709 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44710 {
44711 PyThreadState* __tstate = wxPyBeginAllowThreads();
44712 result = wxMenuItem_GetTextColour(arg1);
44713 wxPyEndAllowThreads(__tstate);
44714 if (PyErr_Occurred()) SWIG_fail;
44715 }
44716 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44717 return resultobj;
44718 fail:
44719 return NULL;
44720 }
44721
44722
44723 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44724 PyObject *resultobj = 0;
44725 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44726 wxColour *arg2 = 0 ;
44727 void *argp1 = 0 ;
44728 int res1 = 0 ;
44729 wxColour temp2 ;
44730 PyObject * obj0 = 0 ;
44731 PyObject * obj1 = 0 ;
44732 char * kwnames[] = {
44733 (char *) "self",(char *) "colBack", NULL
44734 };
44735
44736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44738 if (!SWIG_IsOK(res1)) {
44739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44740 }
44741 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44742 {
44743 arg2 = &temp2;
44744 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44745 }
44746 {
44747 PyThreadState* __tstate = wxPyBeginAllowThreads();
44748 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44749 wxPyEndAllowThreads(__tstate);
44750 if (PyErr_Occurred()) SWIG_fail;
44751 }
44752 resultobj = SWIG_Py_Void();
44753 return resultobj;
44754 fail:
44755 return NULL;
44756 }
44757
44758
44759 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44760 PyObject *resultobj = 0;
44761 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44762 wxColour result;
44763 void *argp1 = 0 ;
44764 int res1 = 0 ;
44765 PyObject *swig_obj[1] ;
44766
44767 if (!args) SWIG_fail;
44768 swig_obj[0] = args;
44769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44770 if (!SWIG_IsOK(res1)) {
44771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44772 }
44773 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44774 {
44775 PyThreadState* __tstate = wxPyBeginAllowThreads();
44776 result = wxMenuItem_GetBackgroundColour(arg1);
44777 wxPyEndAllowThreads(__tstate);
44778 if (PyErr_Occurred()) SWIG_fail;
44779 }
44780 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44781 return resultobj;
44782 fail:
44783 return NULL;
44784 }
44785
44786
44787 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44788 PyObject *resultobj = 0;
44789 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44790 wxBitmap *arg2 = 0 ;
44791 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44792 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44793 void *argp1 = 0 ;
44794 int res1 = 0 ;
44795 void *argp2 = 0 ;
44796 int res2 = 0 ;
44797 void *argp3 = 0 ;
44798 int res3 = 0 ;
44799 PyObject * obj0 = 0 ;
44800 PyObject * obj1 = 0 ;
44801 PyObject * obj2 = 0 ;
44802 char * kwnames[] = {
44803 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44804 };
44805
44806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44808 if (!SWIG_IsOK(res1)) {
44809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44810 }
44811 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44812 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44813 if (!SWIG_IsOK(res2)) {
44814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44815 }
44816 if (!argp2) {
44817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44818 }
44819 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44820 if (obj2) {
44821 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44822 if (!SWIG_IsOK(res3)) {
44823 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44824 }
44825 if (!argp3) {
44826 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44827 }
44828 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44829 }
44830 {
44831 PyThreadState* __tstate = wxPyBeginAllowThreads();
44832 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44833 wxPyEndAllowThreads(__tstate);
44834 if (PyErr_Occurred()) SWIG_fail;
44835 }
44836 resultobj = SWIG_Py_Void();
44837 return resultobj;
44838 fail:
44839 return NULL;
44840 }
44841
44842
44843 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44844 PyObject *resultobj = 0;
44845 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44846 wxBitmap *arg2 = 0 ;
44847 void *argp1 = 0 ;
44848 int res1 = 0 ;
44849 void *argp2 = 0 ;
44850 int res2 = 0 ;
44851 PyObject * obj0 = 0 ;
44852 PyObject * obj1 = 0 ;
44853 char * kwnames[] = {
44854 (char *) "self",(char *) "bmpDisabled", NULL
44855 };
44856
44857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44859 if (!SWIG_IsOK(res1)) {
44860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44861 }
44862 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44863 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44864 if (!SWIG_IsOK(res2)) {
44865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44866 }
44867 if (!argp2) {
44868 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44869 }
44870 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44871 {
44872 PyThreadState* __tstate = wxPyBeginAllowThreads();
44873 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44874 wxPyEndAllowThreads(__tstate);
44875 if (PyErr_Occurred()) SWIG_fail;
44876 }
44877 resultobj = SWIG_Py_Void();
44878 return resultobj;
44879 fail:
44880 return NULL;
44881 }
44882
44883
44884 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44885 PyObject *resultobj = 0;
44886 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44887 wxBitmap *result = 0 ;
44888 void *argp1 = 0 ;
44889 int res1 = 0 ;
44890 PyObject *swig_obj[1] ;
44891
44892 if (!args) SWIG_fail;
44893 swig_obj[0] = args;
44894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44895 if (!SWIG_IsOK(res1)) {
44896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44897 }
44898 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44899 {
44900 PyThreadState* __tstate = wxPyBeginAllowThreads();
44901 {
44902 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44903 result = (wxBitmap *) &_result_ref;
44904 }
44905 wxPyEndAllowThreads(__tstate);
44906 if (PyErr_Occurred()) SWIG_fail;
44907 }
44908 {
44909 wxBitmap* resultptr = new wxBitmap(*result);
44910 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44911 }
44912 return resultobj;
44913 fail:
44914 return NULL;
44915 }
44916
44917
44918 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44919 PyObject *resultobj = 0;
44920 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44921 int arg2 ;
44922 void *argp1 = 0 ;
44923 int res1 = 0 ;
44924 int val2 ;
44925 int ecode2 = 0 ;
44926 PyObject * obj0 = 0 ;
44927 PyObject * obj1 = 0 ;
44928 char * kwnames[] = {
44929 (char *) "self",(char *) "nWidth", NULL
44930 };
44931
44932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44934 if (!SWIG_IsOK(res1)) {
44935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44936 }
44937 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44938 ecode2 = SWIG_AsVal_int(obj1, &val2);
44939 if (!SWIG_IsOK(ecode2)) {
44940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44941 }
44942 arg2 = static_cast< int >(val2);
44943 {
44944 PyThreadState* __tstate = wxPyBeginAllowThreads();
44945 wxMenuItem_SetMarginWidth(arg1,arg2);
44946 wxPyEndAllowThreads(__tstate);
44947 if (PyErr_Occurred()) SWIG_fail;
44948 }
44949 resultobj = SWIG_Py_Void();
44950 return resultobj;
44951 fail:
44952 return NULL;
44953 }
44954
44955
44956 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44957 PyObject *resultobj = 0;
44958 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44959 int result;
44960 void *argp1 = 0 ;
44961 int res1 = 0 ;
44962 PyObject *swig_obj[1] ;
44963
44964 if (!args) SWIG_fail;
44965 swig_obj[0] = args;
44966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44967 if (!SWIG_IsOK(res1)) {
44968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44969 }
44970 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44971 {
44972 PyThreadState* __tstate = wxPyBeginAllowThreads();
44973 result = (int)wxMenuItem_GetMarginWidth(arg1);
44974 wxPyEndAllowThreads(__tstate);
44975 if (PyErr_Occurred()) SWIG_fail;
44976 }
44977 resultobj = SWIG_From_int(static_cast< int >(result));
44978 return resultobj;
44979 fail:
44980 return NULL;
44981 }
44982
44983
44984 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44985 PyObject *resultobj = 0;
44986 int result;
44987
44988 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44989 {
44990 PyThreadState* __tstate = wxPyBeginAllowThreads();
44991 result = (int)wxMenuItem_GetDefaultMarginWidth();
44992 wxPyEndAllowThreads(__tstate);
44993 if (PyErr_Occurred()) SWIG_fail;
44994 }
44995 resultobj = SWIG_From_int(static_cast< int >(result));
44996 return resultobj;
44997 fail:
44998 return NULL;
44999 }
45000
45001
45002 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45003 PyObject *resultobj = 0;
45004 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45005 bool result;
45006 void *argp1 = 0 ;
45007 int res1 = 0 ;
45008 PyObject *swig_obj[1] ;
45009
45010 if (!args) SWIG_fail;
45011 swig_obj[0] = args;
45012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45013 if (!SWIG_IsOK(res1)) {
45014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45015 }
45016 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45017 {
45018 PyThreadState* __tstate = wxPyBeginAllowThreads();
45019 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
45020 wxPyEndAllowThreads(__tstate);
45021 if (PyErr_Occurred()) SWIG_fail;
45022 }
45023 {
45024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45025 }
45026 return resultobj;
45027 fail:
45028 return NULL;
45029 }
45030
45031
45032 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45033 PyObject *resultobj = 0;
45034 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45035 bool arg2 = (bool) true ;
45036 void *argp1 = 0 ;
45037 int res1 = 0 ;
45038 bool val2 ;
45039 int ecode2 = 0 ;
45040 PyObject * obj0 = 0 ;
45041 PyObject * obj1 = 0 ;
45042 char * kwnames[] = {
45043 (char *) "self",(char *) "ownerDrawn", NULL
45044 };
45045
45046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
45047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45048 if (!SWIG_IsOK(res1)) {
45049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45050 }
45051 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45052 if (obj1) {
45053 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45054 if (!SWIG_IsOK(ecode2)) {
45055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
45056 }
45057 arg2 = static_cast< bool >(val2);
45058 }
45059 {
45060 PyThreadState* __tstate = wxPyBeginAllowThreads();
45061 wxMenuItem_SetOwnerDrawn(arg1,arg2);
45062 wxPyEndAllowThreads(__tstate);
45063 if (PyErr_Occurred()) SWIG_fail;
45064 }
45065 resultobj = SWIG_Py_Void();
45066 return resultobj;
45067 fail:
45068 return NULL;
45069 }
45070
45071
45072 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45073 PyObject *resultobj = 0;
45074 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45075 void *argp1 = 0 ;
45076 int res1 = 0 ;
45077 PyObject *swig_obj[1] ;
45078
45079 if (!args) SWIG_fail;
45080 swig_obj[0] = args;
45081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45082 if (!SWIG_IsOK(res1)) {
45083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45084 }
45085 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45086 {
45087 PyThreadState* __tstate = wxPyBeginAllowThreads();
45088 wxMenuItem_ResetOwnerDrawn(arg1);
45089 wxPyEndAllowThreads(__tstate);
45090 if (PyErr_Occurred()) SWIG_fail;
45091 }
45092 resultobj = SWIG_Py_Void();
45093 return resultobj;
45094 fail:
45095 return NULL;
45096 }
45097
45098
45099 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45100 PyObject *obj;
45101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45102 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
45103 return SWIG_Py_Void();
45104 }
45105
45106 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45107 return SWIG_Python_InitShadowInstance(args);
45108 }
45109
45110 SWIGINTERN int ControlNameStr_set(PyObject *) {
45111 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
45112 return 1;
45113 }
45114
45115
45116 SWIGINTERN PyObject *ControlNameStr_get(void) {
45117 PyObject *pyobj = 0;
45118
45119 {
45120 #if wxUSE_UNICODE
45121 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45122 #else
45123 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45124 #endif
45125 }
45126 return pyobj;
45127 }
45128
45129
45130 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45131 PyObject *resultobj = 0;
45132 wxWindow *arg1 = (wxWindow *) 0 ;
45133 int arg2 = (int) -1 ;
45134 wxPoint const &arg3_defvalue = wxDefaultPosition ;
45135 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
45136 wxSize const &arg4_defvalue = wxDefaultSize ;
45137 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
45138 long arg5 = (long) 0 ;
45139 wxValidator const &arg6_defvalue = wxDefaultValidator ;
45140 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
45141 wxString const &arg7_defvalue = wxPyControlNameStr ;
45142 wxString *arg7 = (wxString *) &arg7_defvalue ;
45143 wxControl *result = 0 ;
45144 void *argp1 = 0 ;
45145 int res1 = 0 ;
45146 int val2 ;
45147 int ecode2 = 0 ;
45148 wxPoint temp3 ;
45149 wxSize temp4 ;
45150 long val5 ;
45151 int ecode5 = 0 ;
45152 void *argp6 = 0 ;
45153 int res6 = 0 ;
45154 bool temp7 = false ;
45155 PyObject * obj0 = 0 ;
45156 PyObject * obj1 = 0 ;
45157 PyObject * obj2 = 0 ;
45158 PyObject * obj3 = 0 ;
45159 PyObject * obj4 = 0 ;
45160 PyObject * obj5 = 0 ;
45161 PyObject * obj6 = 0 ;
45162 char * kwnames[] = {
45163 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45164 };
45165
45166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45168 if (!SWIG_IsOK(res1)) {
45169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
45170 }
45171 arg1 = reinterpret_cast< wxWindow * >(argp1);
45172 if (obj1) {
45173 ecode2 = SWIG_AsVal_int(obj1, &val2);
45174 if (!SWIG_IsOK(ecode2)) {
45175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
45176 }
45177 arg2 = static_cast< int >(val2);
45178 }
45179 if (obj2) {
45180 {
45181 arg3 = &temp3;
45182 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
45183 }
45184 }
45185 if (obj3) {
45186 {
45187 arg4 = &temp4;
45188 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
45189 }
45190 }
45191 if (obj4) {
45192 ecode5 = SWIG_AsVal_long(obj4, &val5);
45193 if (!SWIG_IsOK(ecode5)) {
45194 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
45195 }
45196 arg5 = static_cast< long >(val5);
45197 }
45198 if (obj5) {
45199 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
45200 if (!SWIG_IsOK(res6)) {
45201 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45202 }
45203 if (!argp6) {
45204 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45205 }
45206 arg6 = reinterpret_cast< wxValidator * >(argp6);
45207 }
45208 if (obj6) {
45209 {
45210 arg7 = wxString_in_helper(obj6);
45211 if (arg7 == NULL) SWIG_fail;
45212 temp7 = true;
45213 }
45214 }
45215 {
45216 if (!wxPyCheckForApp()) SWIG_fail;
45217 PyThreadState* __tstate = wxPyBeginAllowThreads();
45218 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
45219 wxPyEndAllowThreads(__tstate);
45220 if (PyErr_Occurred()) SWIG_fail;
45221 }
45222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
45223 {
45224 if (temp7)
45225 delete arg7;
45226 }
45227 return resultobj;
45228 fail:
45229 {
45230 if (temp7)
45231 delete arg7;
45232 }
45233 return NULL;
45234 }
45235
45236
45237 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45238 PyObject *resultobj = 0;
45239 wxControl *result = 0 ;
45240
45241 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
45242 {
45243 if (!wxPyCheckForApp()) SWIG_fail;
45244 PyThreadState* __tstate = wxPyBeginAllowThreads();
45245 result = (wxControl *)new wxControl();
45246 wxPyEndAllowThreads(__tstate);
45247 if (PyErr_Occurred()) SWIG_fail;
45248 }
45249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
45250 return resultobj;
45251 fail:
45252 return NULL;
45253 }
45254
45255
45256 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45257 PyObject *resultobj = 0;
45258 wxControl *arg1 = (wxControl *) 0 ;
45259 wxWindow *arg2 = (wxWindow *) 0 ;
45260 int arg3 = (int) -1 ;
45261 wxPoint const &arg4_defvalue = wxDefaultPosition ;
45262 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
45263 wxSize const &arg5_defvalue = wxDefaultSize ;
45264 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
45265 long arg6 = (long) 0 ;
45266 wxValidator const &arg7_defvalue = wxDefaultValidator ;
45267 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
45268 wxString const &arg8_defvalue = wxPyControlNameStr ;
45269 wxString *arg8 = (wxString *) &arg8_defvalue ;
45270 bool result;
45271 void *argp1 = 0 ;
45272 int res1 = 0 ;
45273 void *argp2 = 0 ;
45274 int res2 = 0 ;
45275 int val3 ;
45276 int ecode3 = 0 ;
45277 wxPoint temp4 ;
45278 wxSize temp5 ;
45279 long val6 ;
45280 int ecode6 = 0 ;
45281 void *argp7 = 0 ;
45282 int res7 = 0 ;
45283 bool temp8 = false ;
45284 PyObject * obj0 = 0 ;
45285 PyObject * obj1 = 0 ;
45286 PyObject * obj2 = 0 ;
45287 PyObject * obj3 = 0 ;
45288 PyObject * obj4 = 0 ;
45289 PyObject * obj5 = 0 ;
45290 PyObject * obj6 = 0 ;
45291 PyObject * obj7 = 0 ;
45292 char * kwnames[] = {
45293 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45294 };
45295
45296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
45297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45298 if (!SWIG_IsOK(res1)) {
45299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
45300 }
45301 arg1 = reinterpret_cast< wxControl * >(argp1);
45302 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45303 if (!SWIG_IsOK(res2)) {
45304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
45305 }
45306 arg2 = reinterpret_cast< wxWindow * >(argp2);
45307 if (obj2) {
45308 ecode3 = SWIG_AsVal_int(obj2, &val3);
45309 if (!SWIG_IsOK(ecode3)) {
45310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
45311 }
45312 arg3 = static_cast< int >(val3);
45313 }
45314 if (obj3) {
45315 {
45316 arg4 = &temp4;
45317 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
45318 }
45319 }
45320 if (obj4) {
45321 {
45322 arg5 = &temp5;
45323 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
45324 }
45325 }
45326 if (obj5) {
45327 ecode6 = SWIG_AsVal_long(obj5, &val6);
45328 if (!SWIG_IsOK(ecode6)) {
45329 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
45330 }
45331 arg6 = static_cast< long >(val6);
45332 }
45333 if (obj6) {
45334 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
45335 if (!SWIG_IsOK(res7)) {
45336 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45337 }
45338 if (!argp7) {
45339 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45340 }
45341 arg7 = reinterpret_cast< wxValidator * >(argp7);
45342 }
45343 if (obj7) {
45344 {
45345 arg8 = wxString_in_helper(obj7);
45346 if (arg8 == NULL) SWIG_fail;
45347 temp8 = true;
45348 }
45349 }
45350 {
45351 PyThreadState* __tstate = wxPyBeginAllowThreads();
45352 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
45353 wxPyEndAllowThreads(__tstate);
45354 if (PyErr_Occurred()) SWIG_fail;
45355 }
45356 {
45357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45358 }
45359 {
45360 if (temp8)
45361 delete arg8;
45362 }
45363 return resultobj;
45364 fail:
45365 {
45366 if (temp8)
45367 delete arg8;
45368 }
45369 return NULL;
45370 }
45371
45372
45373 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45374 PyObject *resultobj = 0;
45375 wxControl *arg1 = (wxControl *) 0 ;
45376 int result;
45377 void *argp1 = 0 ;
45378 int res1 = 0 ;
45379 PyObject *swig_obj[1] ;
45380
45381 if (!args) SWIG_fail;
45382 swig_obj[0] = args;
45383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45384 if (!SWIG_IsOK(res1)) {
45385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
45386 }
45387 arg1 = reinterpret_cast< wxControl * >(argp1);
45388 {
45389 PyThreadState* __tstate = wxPyBeginAllowThreads();
45390 result = (int)((wxControl const *)arg1)->GetAlignment();
45391 wxPyEndAllowThreads(__tstate);
45392 if (PyErr_Occurred()) SWIG_fail;
45393 }
45394 resultobj = SWIG_From_int(static_cast< int >(result));
45395 return resultobj;
45396 fail:
45397 return NULL;
45398 }
45399
45400
45401 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45402 PyObject *resultobj = 0;
45403 wxControl *arg1 = (wxControl *) 0 ;
45404 wxString result;
45405 void *argp1 = 0 ;
45406 int res1 = 0 ;
45407 PyObject *swig_obj[1] ;
45408
45409 if (!args) SWIG_fail;
45410 swig_obj[0] = args;
45411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45412 if (!SWIG_IsOK(res1)) {
45413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
45414 }
45415 arg1 = reinterpret_cast< wxControl * >(argp1);
45416 {
45417 PyThreadState* __tstate = wxPyBeginAllowThreads();
45418 result = ((wxControl const *)arg1)->GetLabelText();
45419 wxPyEndAllowThreads(__tstate);
45420 if (PyErr_Occurred()) SWIG_fail;
45421 }
45422 {
45423 #if wxUSE_UNICODE
45424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45425 #else
45426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45427 #endif
45428 }
45429 return resultobj;
45430 fail:
45431 return NULL;
45432 }
45433
45434
45435 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45436 PyObject *resultobj = 0;
45437 wxControl *arg1 = (wxControl *) 0 ;
45438 wxCommandEvent *arg2 = 0 ;
45439 void *argp1 = 0 ;
45440 int res1 = 0 ;
45441 void *argp2 = 0 ;
45442 int res2 = 0 ;
45443 PyObject * obj0 = 0 ;
45444 PyObject * obj1 = 0 ;
45445 char * kwnames[] = {
45446 (char *) "self",(char *) "event", NULL
45447 };
45448
45449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
45450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45451 if (!SWIG_IsOK(res1)) {
45452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
45453 }
45454 arg1 = reinterpret_cast< wxControl * >(argp1);
45455 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
45456 if (!SWIG_IsOK(res2)) {
45457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45458 }
45459 if (!argp2) {
45460 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45461 }
45462 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
45463 {
45464 PyThreadState* __tstate = wxPyBeginAllowThreads();
45465 (arg1)->Command(*arg2);
45466 wxPyEndAllowThreads(__tstate);
45467 if (PyErr_Occurred()) SWIG_fail;
45468 }
45469 resultobj = SWIG_Py_Void();
45470 return resultobj;
45471 fail:
45472 return NULL;
45473 }
45474
45475
45476 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45477 PyObject *resultobj = 0;
45478 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
45479 SwigValueWrapper<wxVisualAttributes > result;
45480 int val1 ;
45481 int ecode1 = 0 ;
45482 PyObject * obj0 = 0 ;
45483 char * kwnames[] = {
45484 (char *) "variant", NULL
45485 };
45486
45487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
45488 if (obj0) {
45489 ecode1 = SWIG_AsVal_int(obj0, &val1);
45490 if (!SWIG_IsOK(ecode1)) {
45491 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
45492 }
45493 arg1 = static_cast< wxWindowVariant >(val1);
45494 }
45495 {
45496 if (!wxPyCheckForApp()) SWIG_fail;
45497 PyThreadState* __tstate = wxPyBeginAllowThreads();
45498 result = wxControl::GetClassDefaultAttributes(arg1);
45499 wxPyEndAllowThreads(__tstate);
45500 if (PyErr_Occurred()) SWIG_fail;
45501 }
45502 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
45503 return resultobj;
45504 fail:
45505 return NULL;
45506 }
45507
45508
45509 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45510 PyObject *obj;
45511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45512 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
45513 return SWIG_Py_Void();
45514 }
45515
45516 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45517 return SWIG_Python_InitShadowInstance(args);
45518 }
45519
45520 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45521 PyObject *resultobj = 0;
45522 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45523 wxString *arg2 = 0 ;
45524 PyObject *arg3 = (PyObject *) NULL ;
45525 int result;
45526 void *argp1 = 0 ;
45527 int res1 = 0 ;
45528 bool temp2 = false ;
45529 PyObject * obj0 = 0 ;
45530 PyObject * obj1 = 0 ;
45531 PyObject * obj2 = 0 ;
45532 char * kwnames[] = {
45533 (char *) "self",(char *) "item",(char *) "clientData", NULL
45534 };
45535
45536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45538 if (!SWIG_IsOK(res1)) {
45539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45540 }
45541 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45542 {
45543 arg2 = wxString_in_helper(obj1);
45544 if (arg2 == NULL) SWIG_fail;
45545 temp2 = true;
45546 }
45547 if (obj2) {
45548 arg3 = obj2;
45549 }
45550 {
45551 PyThreadState* __tstate = wxPyBeginAllowThreads();
45552 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45553 wxPyEndAllowThreads(__tstate);
45554 if (PyErr_Occurred()) SWIG_fail;
45555 }
45556 resultobj = SWIG_From_int(static_cast< int >(result));
45557 {
45558 if (temp2)
45559 delete arg2;
45560 }
45561 return resultobj;
45562 fail:
45563 {
45564 if (temp2)
45565 delete arg2;
45566 }
45567 return NULL;
45568 }
45569
45570
45571 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45572 PyObject *resultobj = 0;
45573 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45574 wxArrayString *arg2 = 0 ;
45575 void *argp1 = 0 ;
45576 int res1 = 0 ;
45577 bool temp2 = false ;
45578 PyObject * obj0 = 0 ;
45579 PyObject * obj1 = 0 ;
45580 char * kwnames[] = {
45581 (char *) "self",(char *) "strings", NULL
45582 };
45583
45584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45586 if (!SWIG_IsOK(res1)) {
45587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45588 }
45589 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45590 {
45591 if (! PySequence_Check(obj1)) {
45592 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45593 SWIG_fail;
45594 }
45595 arg2 = new wxArrayString;
45596 temp2 = true;
45597 int i, len=PySequence_Length(obj1);
45598 for (i=0; i<len; i++) {
45599 PyObject* item = PySequence_GetItem(obj1, i);
45600 wxString* s = wxString_in_helper(item);
45601 if (PyErr_Occurred()) SWIG_fail;
45602 arg2->Add(*s);
45603 delete s;
45604 Py_DECREF(item);
45605 }
45606 }
45607 {
45608 PyThreadState* __tstate = wxPyBeginAllowThreads();
45609 (arg1)->Append((wxArrayString const &)*arg2);
45610 wxPyEndAllowThreads(__tstate);
45611 if (PyErr_Occurred()) SWIG_fail;
45612 }
45613 resultobj = SWIG_Py_Void();
45614 {
45615 if (temp2) delete arg2;
45616 }
45617 return resultobj;
45618 fail:
45619 {
45620 if (temp2) delete arg2;
45621 }
45622 return NULL;
45623 }
45624
45625
45626 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45627 PyObject *resultobj = 0;
45628 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45629 wxString *arg2 = 0 ;
45630 unsigned int arg3 ;
45631 PyObject *arg4 = (PyObject *) NULL ;
45632 int result;
45633 void *argp1 = 0 ;
45634 int res1 = 0 ;
45635 bool temp2 = false ;
45636 unsigned int val3 ;
45637 int ecode3 = 0 ;
45638 PyObject * obj0 = 0 ;
45639 PyObject * obj1 = 0 ;
45640 PyObject * obj2 = 0 ;
45641 PyObject * obj3 = 0 ;
45642 char * kwnames[] = {
45643 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45644 };
45645
45646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45648 if (!SWIG_IsOK(res1)) {
45649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45650 }
45651 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45652 {
45653 arg2 = wxString_in_helper(obj1);
45654 if (arg2 == NULL) SWIG_fail;
45655 temp2 = true;
45656 }
45657 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45658 if (!SWIG_IsOK(ecode3)) {
45659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45660 }
45661 arg3 = static_cast< unsigned int >(val3);
45662 if (obj3) {
45663 arg4 = obj3;
45664 }
45665 {
45666 PyThreadState* __tstate = wxPyBeginAllowThreads();
45667 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45668 wxPyEndAllowThreads(__tstate);
45669 if (PyErr_Occurred()) SWIG_fail;
45670 }
45671 resultobj = SWIG_From_int(static_cast< int >(result));
45672 {
45673 if (temp2)
45674 delete arg2;
45675 }
45676 return resultobj;
45677 fail:
45678 {
45679 if (temp2)
45680 delete arg2;
45681 }
45682 return NULL;
45683 }
45684
45685
45686 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45687 PyObject *resultobj = 0;
45688 wxItemContainer *arg1 = (wxItemContainer *) 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_wxItemContainer, 0 | 0 );
45696 if (!SWIG_IsOK(res1)) {
45697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45698 }
45699 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45700 {
45701 PyThreadState* __tstate = wxPyBeginAllowThreads();
45702 (arg1)->Clear();
45703 wxPyEndAllowThreads(__tstate);
45704 if (PyErr_Occurred()) SWIG_fail;
45705 }
45706 resultobj = SWIG_Py_Void();
45707 return resultobj;
45708 fail:
45709 return NULL;
45710 }
45711
45712
45713 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45714 PyObject *resultobj = 0;
45715 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45716 unsigned int arg2 ;
45717 void *argp1 = 0 ;
45718 int res1 = 0 ;
45719 unsigned int val2 ;
45720 int ecode2 = 0 ;
45721 PyObject * obj0 = 0 ;
45722 PyObject * obj1 = 0 ;
45723 char * kwnames[] = {
45724 (char *) "self",(char *) "n", NULL
45725 };
45726
45727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45729 if (!SWIG_IsOK(res1)) {
45730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45731 }
45732 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45733 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45734 if (!SWIG_IsOK(ecode2)) {
45735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45736 }
45737 arg2 = static_cast< unsigned int >(val2);
45738 {
45739 PyThreadState* __tstate = wxPyBeginAllowThreads();
45740 (arg1)->Delete(arg2);
45741 wxPyEndAllowThreads(__tstate);
45742 if (PyErr_Occurred()) SWIG_fail;
45743 }
45744 resultobj = SWIG_Py_Void();
45745 return resultobj;
45746 fail:
45747 return NULL;
45748 }
45749
45750
45751 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45752 PyObject *resultobj = 0;
45753 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45754 unsigned int arg2 ;
45755 PyObject *result = 0 ;
45756 void *argp1 = 0 ;
45757 int res1 = 0 ;
45758 unsigned int val2 ;
45759 int ecode2 = 0 ;
45760 PyObject * obj0 = 0 ;
45761 PyObject * obj1 = 0 ;
45762 char * kwnames[] = {
45763 (char *) "self",(char *) "n", NULL
45764 };
45765
45766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45768 if (!SWIG_IsOK(res1)) {
45769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45770 }
45771 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45772 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45773 if (!SWIG_IsOK(ecode2)) {
45774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45775 }
45776 arg2 = static_cast< unsigned int >(val2);
45777 {
45778 PyThreadState* __tstate = wxPyBeginAllowThreads();
45779 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45780 wxPyEndAllowThreads(__tstate);
45781 if (PyErr_Occurred()) SWIG_fail;
45782 }
45783 resultobj = result;
45784 return resultobj;
45785 fail:
45786 return NULL;
45787 }
45788
45789
45790 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45791 PyObject *resultobj = 0;
45792 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45793 unsigned int arg2 ;
45794 PyObject *arg3 = (PyObject *) 0 ;
45795 void *argp1 = 0 ;
45796 int res1 = 0 ;
45797 unsigned int val2 ;
45798 int ecode2 = 0 ;
45799 PyObject * obj0 = 0 ;
45800 PyObject * obj1 = 0 ;
45801 PyObject * obj2 = 0 ;
45802 char * kwnames[] = {
45803 (char *) "self",(char *) "n",(char *) "clientData", NULL
45804 };
45805
45806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45808 if (!SWIG_IsOK(res1)) {
45809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45810 }
45811 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45812 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45813 if (!SWIG_IsOK(ecode2)) {
45814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45815 }
45816 arg2 = static_cast< unsigned int >(val2);
45817 arg3 = obj2;
45818 {
45819 PyThreadState* __tstate = wxPyBeginAllowThreads();
45820 wxItemContainer_SetClientData(arg1,arg2,arg3);
45821 wxPyEndAllowThreads(__tstate);
45822 if (PyErr_Occurred()) SWIG_fail;
45823 }
45824 resultobj = SWIG_Py_Void();
45825 return resultobj;
45826 fail:
45827 return NULL;
45828 }
45829
45830
45831 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45832 PyObject *resultobj = 0;
45833 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45834 unsigned int result;
45835 void *argp1 = 0 ;
45836 int res1 = 0 ;
45837 PyObject *swig_obj[1] ;
45838
45839 if (!args) SWIG_fail;
45840 swig_obj[0] = args;
45841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45842 if (!SWIG_IsOK(res1)) {
45843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45844 }
45845 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45846 {
45847 PyThreadState* __tstate = wxPyBeginAllowThreads();
45848 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45849 wxPyEndAllowThreads(__tstate);
45850 if (PyErr_Occurred()) SWIG_fail;
45851 }
45852 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45853 return resultobj;
45854 fail:
45855 return NULL;
45856 }
45857
45858
45859 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45860 PyObject *resultobj = 0;
45861 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45862 bool result;
45863 void *argp1 = 0 ;
45864 int res1 = 0 ;
45865 PyObject *swig_obj[1] ;
45866
45867 if (!args) SWIG_fail;
45868 swig_obj[0] = args;
45869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45870 if (!SWIG_IsOK(res1)) {
45871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45872 }
45873 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45874 {
45875 PyThreadState* __tstate = wxPyBeginAllowThreads();
45876 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45877 wxPyEndAllowThreads(__tstate);
45878 if (PyErr_Occurred()) SWIG_fail;
45879 }
45880 {
45881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45882 }
45883 return resultobj;
45884 fail:
45885 return NULL;
45886 }
45887
45888
45889 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45890 PyObject *resultobj = 0;
45891 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45892 unsigned int arg2 ;
45893 wxString result;
45894 void *argp1 = 0 ;
45895 int res1 = 0 ;
45896 unsigned int val2 ;
45897 int ecode2 = 0 ;
45898 PyObject * obj0 = 0 ;
45899 PyObject * obj1 = 0 ;
45900 char * kwnames[] = {
45901 (char *) "self",(char *) "n", NULL
45902 };
45903
45904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45906 if (!SWIG_IsOK(res1)) {
45907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45908 }
45909 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45910 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45911 if (!SWIG_IsOK(ecode2)) {
45912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45913 }
45914 arg2 = static_cast< unsigned int >(val2);
45915 {
45916 PyThreadState* __tstate = wxPyBeginAllowThreads();
45917 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45918 wxPyEndAllowThreads(__tstate);
45919 if (PyErr_Occurred()) SWIG_fail;
45920 }
45921 {
45922 #if wxUSE_UNICODE
45923 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45924 #else
45925 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45926 #endif
45927 }
45928 return resultobj;
45929 fail:
45930 return NULL;
45931 }
45932
45933
45934 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45935 PyObject *resultobj = 0;
45936 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45937 wxArrayString result;
45938 void *argp1 = 0 ;
45939 int res1 = 0 ;
45940 PyObject *swig_obj[1] ;
45941
45942 if (!args) SWIG_fail;
45943 swig_obj[0] = args;
45944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45945 if (!SWIG_IsOK(res1)) {
45946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45947 }
45948 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45949 {
45950 PyThreadState* __tstate = wxPyBeginAllowThreads();
45951 result = ((wxItemContainer const *)arg1)->GetStrings();
45952 wxPyEndAllowThreads(__tstate);
45953 if (PyErr_Occurred()) SWIG_fail;
45954 }
45955 {
45956 resultobj = wxArrayString2PyList_helper(result);
45957 }
45958 return resultobj;
45959 fail:
45960 return NULL;
45961 }
45962
45963
45964 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45965 PyObject *resultobj = 0;
45966 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45967 unsigned int arg2 ;
45968 wxString *arg3 = 0 ;
45969 void *argp1 = 0 ;
45970 int res1 = 0 ;
45971 unsigned int val2 ;
45972 int ecode2 = 0 ;
45973 bool temp3 = false ;
45974 PyObject * obj0 = 0 ;
45975 PyObject * obj1 = 0 ;
45976 PyObject * obj2 = 0 ;
45977 char * kwnames[] = {
45978 (char *) "self",(char *) "n",(char *) "s", NULL
45979 };
45980
45981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45983 if (!SWIG_IsOK(res1)) {
45984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45985 }
45986 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45987 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45988 if (!SWIG_IsOK(ecode2)) {
45989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45990 }
45991 arg2 = static_cast< unsigned int >(val2);
45992 {
45993 arg3 = wxString_in_helper(obj2);
45994 if (arg3 == NULL) SWIG_fail;
45995 temp3 = true;
45996 }
45997 {
45998 PyThreadState* __tstate = wxPyBeginAllowThreads();
45999 (arg1)->SetString(arg2,(wxString const &)*arg3);
46000 wxPyEndAllowThreads(__tstate);
46001 if (PyErr_Occurred()) SWIG_fail;
46002 }
46003 resultobj = SWIG_Py_Void();
46004 {
46005 if (temp3)
46006 delete arg3;
46007 }
46008 return resultobj;
46009 fail:
46010 {
46011 if (temp3)
46012 delete arg3;
46013 }
46014 return NULL;
46015 }
46016
46017
46018 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46019 PyObject *resultobj = 0;
46020 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46021 wxString *arg2 = 0 ;
46022 int result;
46023 void *argp1 = 0 ;
46024 int res1 = 0 ;
46025 bool temp2 = false ;
46026 PyObject * obj0 = 0 ;
46027 PyObject * obj1 = 0 ;
46028 char * kwnames[] = {
46029 (char *) "self",(char *) "s", NULL
46030 };
46031
46032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
46033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46034 if (!SWIG_IsOK(res1)) {
46035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46036 }
46037 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46038 {
46039 arg2 = wxString_in_helper(obj1);
46040 if (arg2 == NULL) SWIG_fail;
46041 temp2 = true;
46042 }
46043 {
46044 PyThreadState* __tstate = wxPyBeginAllowThreads();
46045 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
46046 wxPyEndAllowThreads(__tstate);
46047 if (PyErr_Occurred()) SWIG_fail;
46048 }
46049 resultobj = SWIG_From_int(static_cast< int >(result));
46050 {
46051 if (temp2)
46052 delete arg2;
46053 }
46054 return resultobj;
46055 fail:
46056 {
46057 if (temp2)
46058 delete arg2;
46059 }
46060 return NULL;
46061 }
46062
46063
46064 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46065 PyObject *resultobj = 0;
46066 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46067 int arg2 ;
46068 void *argp1 = 0 ;
46069 int res1 = 0 ;
46070 int val2 ;
46071 int ecode2 = 0 ;
46072 PyObject * obj0 = 0 ;
46073 PyObject * obj1 = 0 ;
46074 char * kwnames[] = {
46075 (char *) "self",(char *) "n", NULL
46076 };
46077
46078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46080 if (!SWIG_IsOK(res1)) {
46081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46082 }
46083 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46084 ecode2 = SWIG_AsVal_int(obj1, &val2);
46085 if (!SWIG_IsOK(ecode2)) {
46086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
46087 }
46088 arg2 = static_cast< int >(val2);
46089 {
46090 PyThreadState* __tstate = wxPyBeginAllowThreads();
46091 (arg1)->SetSelection(arg2);
46092 wxPyEndAllowThreads(__tstate);
46093 if (PyErr_Occurred()) SWIG_fail;
46094 }
46095 resultobj = SWIG_Py_Void();
46096 return resultobj;
46097 fail:
46098 return NULL;
46099 }
46100
46101
46102 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46103 PyObject *resultobj = 0;
46104 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46105 int result;
46106 void *argp1 = 0 ;
46107 int res1 = 0 ;
46108 PyObject *swig_obj[1] ;
46109
46110 if (!args) SWIG_fail;
46111 swig_obj[0] = args;
46112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46113 if (!SWIG_IsOK(res1)) {
46114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46115 }
46116 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46117 {
46118 PyThreadState* __tstate = wxPyBeginAllowThreads();
46119 result = (int)((wxItemContainer const *)arg1)->GetSelection();
46120 wxPyEndAllowThreads(__tstate);
46121 if (PyErr_Occurred()) SWIG_fail;
46122 }
46123 resultobj = SWIG_From_int(static_cast< int >(result));
46124 return resultobj;
46125 fail:
46126 return NULL;
46127 }
46128
46129
46130 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46131 PyObject *resultobj = 0;
46132 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46133 wxString *arg2 = 0 ;
46134 bool result;
46135 void *argp1 = 0 ;
46136 int res1 = 0 ;
46137 bool temp2 = false ;
46138 PyObject * obj0 = 0 ;
46139 PyObject * obj1 = 0 ;
46140 char * kwnames[] = {
46141 (char *) "self",(char *) "s", NULL
46142 };
46143
46144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46146 if (!SWIG_IsOK(res1)) {
46147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46148 }
46149 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46150 {
46151 arg2 = wxString_in_helper(obj1);
46152 if (arg2 == NULL) SWIG_fail;
46153 temp2 = true;
46154 }
46155 {
46156 PyThreadState* __tstate = wxPyBeginAllowThreads();
46157 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
46158 wxPyEndAllowThreads(__tstate);
46159 if (PyErr_Occurred()) SWIG_fail;
46160 }
46161 {
46162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46163 }
46164 {
46165 if (temp2)
46166 delete arg2;
46167 }
46168 return resultobj;
46169 fail:
46170 {
46171 if (temp2)
46172 delete arg2;
46173 }
46174 return NULL;
46175 }
46176
46177
46178 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46179 PyObject *resultobj = 0;
46180 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46181 wxString result;
46182 void *argp1 = 0 ;
46183 int res1 = 0 ;
46184 PyObject *swig_obj[1] ;
46185
46186 if (!args) SWIG_fail;
46187 swig_obj[0] = args;
46188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46189 if (!SWIG_IsOK(res1)) {
46190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46191 }
46192 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46193 {
46194 PyThreadState* __tstate = wxPyBeginAllowThreads();
46195 result = ((wxItemContainer const *)arg1)->GetStringSelection();
46196 wxPyEndAllowThreads(__tstate);
46197 if (PyErr_Occurred()) SWIG_fail;
46198 }
46199 {
46200 #if wxUSE_UNICODE
46201 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46202 #else
46203 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46204 #endif
46205 }
46206 return resultobj;
46207 fail:
46208 return NULL;
46209 }
46210
46211
46212 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46213 PyObject *resultobj = 0;
46214 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46215 int arg2 ;
46216 void *argp1 = 0 ;
46217 int res1 = 0 ;
46218 int val2 ;
46219 int ecode2 = 0 ;
46220 PyObject * obj0 = 0 ;
46221 PyObject * obj1 = 0 ;
46222 char * kwnames[] = {
46223 (char *) "self",(char *) "n", NULL
46224 };
46225
46226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
46227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46228 if (!SWIG_IsOK(res1)) {
46229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46230 }
46231 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46232 ecode2 = SWIG_AsVal_int(obj1, &val2);
46233 if (!SWIG_IsOK(ecode2)) {
46234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
46235 }
46236 arg2 = static_cast< int >(val2);
46237 {
46238 PyThreadState* __tstate = wxPyBeginAllowThreads();
46239 (arg1)->Select(arg2);
46240 wxPyEndAllowThreads(__tstate);
46241 if (PyErr_Occurred()) SWIG_fail;
46242 }
46243 resultobj = SWIG_Py_Void();
46244 return resultobj;
46245 fail:
46246 return NULL;
46247 }
46248
46249
46250 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46251 PyObject *obj;
46252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46253 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
46254 return SWIG_Py_Void();
46255 }
46256
46257 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46258 PyObject *obj;
46259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46260 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
46261 return SWIG_Py_Void();
46262 }
46263
46264 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46265 PyObject *resultobj = 0;
46266 wxSizerItem *result = 0 ;
46267
46268 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
46269 {
46270 PyThreadState* __tstate = wxPyBeginAllowThreads();
46271 result = (wxSizerItem *)new wxSizerItem();
46272 wxPyEndAllowThreads(__tstate);
46273 if (PyErr_Occurred()) SWIG_fail;
46274 }
46275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
46276 return resultobj;
46277 fail:
46278 return NULL;
46279 }
46280
46281
46282 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46283 PyObject *resultobj = 0;
46284 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46285 void *argp1 = 0 ;
46286 int res1 = 0 ;
46287 PyObject *swig_obj[1] ;
46288
46289 if (!args) SWIG_fail;
46290 swig_obj[0] = args;
46291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46292 if (!SWIG_IsOK(res1)) {
46293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46294 }
46295 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46296 {
46297 PyThreadState* __tstate = wxPyBeginAllowThreads();
46298 delete arg1;
46299
46300 wxPyEndAllowThreads(__tstate);
46301 if (PyErr_Occurred()) SWIG_fail;
46302 }
46303 resultobj = SWIG_Py_Void();
46304 return resultobj;
46305 fail:
46306 return NULL;
46307 }
46308
46309
46310 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46311 PyObject *resultobj = 0;
46312 wxWindow *arg1 = (wxWindow *) 0 ;
46313 int arg2 ;
46314 int arg3 ;
46315 int arg4 ;
46316 PyObject *arg5 = (PyObject *) NULL ;
46317 wxSizerItem *result = 0 ;
46318 void *argp1 = 0 ;
46319 int res1 = 0 ;
46320 int val2 ;
46321 int ecode2 = 0 ;
46322 int val3 ;
46323 int ecode3 = 0 ;
46324 int val4 ;
46325 int ecode4 = 0 ;
46326 PyObject * obj0 = 0 ;
46327 PyObject * obj1 = 0 ;
46328 PyObject * obj2 = 0 ;
46329 PyObject * obj3 = 0 ;
46330 PyObject * obj4 = 0 ;
46331 char * kwnames[] = {
46332 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46333 };
46334
46335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
46337 if (!SWIG_IsOK(res1)) {
46338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
46339 }
46340 arg1 = reinterpret_cast< wxWindow * >(argp1);
46341 ecode2 = SWIG_AsVal_int(obj1, &val2);
46342 if (!SWIG_IsOK(ecode2)) {
46343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
46344 }
46345 arg2 = static_cast< int >(val2);
46346 ecode3 = SWIG_AsVal_int(obj2, &val3);
46347 if (!SWIG_IsOK(ecode3)) {
46348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
46349 }
46350 arg3 = static_cast< int >(val3);
46351 ecode4 = SWIG_AsVal_int(obj3, &val4);
46352 if (!SWIG_IsOK(ecode4)) {
46353 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
46354 }
46355 arg4 = static_cast< int >(val4);
46356 if (obj4) {
46357 arg5 = obj4;
46358 }
46359 {
46360 PyThreadState* __tstate = wxPyBeginAllowThreads();
46361 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46362 wxPyEndAllowThreads(__tstate);
46363 if (PyErr_Occurred()) SWIG_fail;
46364 }
46365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46366 return resultobj;
46367 fail:
46368 return NULL;
46369 }
46370
46371
46372 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46373 PyObject *resultobj = 0;
46374 int arg1 ;
46375 int arg2 ;
46376 int arg3 ;
46377 int arg4 ;
46378 int arg5 ;
46379 PyObject *arg6 = (PyObject *) NULL ;
46380 wxSizerItem *result = 0 ;
46381 int val1 ;
46382 int ecode1 = 0 ;
46383 int val2 ;
46384 int ecode2 = 0 ;
46385 int val3 ;
46386 int ecode3 = 0 ;
46387 int val4 ;
46388 int ecode4 = 0 ;
46389 int val5 ;
46390 int ecode5 = 0 ;
46391 PyObject * obj0 = 0 ;
46392 PyObject * obj1 = 0 ;
46393 PyObject * obj2 = 0 ;
46394 PyObject * obj3 = 0 ;
46395 PyObject * obj4 = 0 ;
46396 PyObject * obj5 = 0 ;
46397 char * kwnames[] = {
46398 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46399 };
46400
46401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46402 ecode1 = SWIG_AsVal_int(obj0, &val1);
46403 if (!SWIG_IsOK(ecode1)) {
46404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
46405 }
46406 arg1 = static_cast< int >(val1);
46407 ecode2 = SWIG_AsVal_int(obj1, &val2);
46408 if (!SWIG_IsOK(ecode2)) {
46409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
46410 }
46411 arg2 = static_cast< int >(val2);
46412 ecode3 = SWIG_AsVal_int(obj2, &val3);
46413 if (!SWIG_IsOK(ecode3)) {
46414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
46415 }
46416 arg3 = static_cast< int >(val3);
46417 ecode4 = SWIG_AsVal_int(obj3, &val4);
46418 if (!SWIG_IsOK(ecode4)) {
46419 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
46420 }
46421 arg4 = static_cast< int >(val4);
46422 ecode5 = SWIG_AsVal_int(obj4, &val5);
46423 if (!SWIG_IsOK(ecode5)) {
46424 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
46425 }
46426 arg5 = static_cast< int >(val5);
46427 if (obj5) {
46428 arg6 = obj5;
46429 }
46430 {
46431 PyThreadState* __tstate = wxPyBeginAllowThreads();
46432 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
46433 wxPyEndAllowThreads(__tstate);
46434 if (PyErr_Occurred()) SWIG_fail;
46435 }
46436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46437 return resultobj;
46438 fail:
46439 return NULL;
46440 }
46441
46442
46443 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46444 PyObject *resultobj = 0;
46445 wxSizer *arg1 = (wxSizer *) 0 ;
46446 int arg2 ;
46447 int arg3 ;
46448 int arg4 ;
46449 PyObject *arg5 = (PyObject *) NULL ;
46450 wxSizerItem *result = 0 ;
46451 int res1 = 0 ;
46452 int val2 ;
46453 int ecode2 = 0 ;
46454 int val3 ;
46455 int ecode3 = 0 ;
46456 int val4 ;
46457 int ecode4 = 0 ;
46458 PyObject * obj0 = 0 ;
46459 PyObject * obj1 = 0 ;
46460 PyObject * obj2 = 0 ;
46461 PyObject * obj3 = 0 ;
46462 PyObject * obj4 = 0 ;
46463 char * kwnames[] = {
46464 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46465 };
46466
46467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46468 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46469 if (!SWIG_IsOK(res1)) {
46470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46471 }
46472 ecode2 = SWIG_AsVal_int(obj1, &val2);
46473 if (!SWIG_IsOK(ecode2)) {
46474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
46475 }
46476 arg2 = static_cast< int >(val2);
46477 ecode3 = SWIG_AsVal_int(obj2, &val3);
46478 if (!SWIG_IsOK(ecode3)) {
46479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
46480 }
46481 arg3 = static_cast< int >(val3);
46482 ecode4 = SWIG_AsVal_int(obj3, &val4);
46483 if (!SWIG_IsOK(ecode4)) {
46484 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
46485 }
46486 arg4 = static_cast< int >(val4);
46487 if (obj4) {
46488 arg5 = obj4;
46489 }
46490 {
46491 PyThreadState* __tstate = wxPyBeginAllowThreads();
46492 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46493 wxPyEndAllowThreads(__tstate);
46494 if (PyErr_Occurred()) SWIG_fail;
46495 }
46496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46497 return resultobj;
46498 fail:
46499 return NULL;
46500 }
46501
46502
46503 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46504 PyObject *resultobj = 0;
46505 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46506 void *argp1 = 0 ;
46507 int res1 = 0 ;
46508 PyObject *swig_obj[1] ;
46509
46510 if (!args) SWIG_fail;
46511 swig_obj[0] = args;
46512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46513 if (!SWIG_IsOK(res1)) {
46514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46515 }
46516 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46517 {
46518 PyThreadState* __tstate = wxPyBeginAllowThreads();
46519 (arg1)->DeleteWindows();
46520 wxPyEndAllowThreads(__tstate);
46521 if (PyErr_Occurred()) SWIG_fail;
46522 }
46523 resultobj = SWIG_Py_Void();
46524 return resultobj;
46525 fail:
46526 return NULL;
46527 }
46528
46529
46530 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46531 PyObject *resultobj = 0;
46532 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46533 void *argp1 = 0 ;
46534 int res1 = 0 ;
46535 PyObject *swig_obj[1] ;
46536
46537 if (!args) SWIG_fail;
46538 swig_obj[0] = args;
46539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46540 if (!SWIG_IsOK(res1)) {
46541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46542 }
46543 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46544 {
46545 PyThreadState* __tstate = wxPyBeginAllowThreads();
46546 (arg1)->DetachSizer();
46547 wxPyEndAllowThreads(__tstate);
46548 if (PyErr_Occurred()) SWIG_fail;
46549 }
46550 resultobj = SWIG_Py_Void();
46551 return resultobj;
46552 fail:
46553 return NULL;
46554 }
46555
46556
46557 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46558 PyObject *resultobj = 0;
46559 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46560 wxSize result;
46561 void *argp1 = 0 ;
46562 int res1 = 0 ;
46563 PyObject *swig_obj[1] ;
46564
46565 if (!args) SWIG_fail;
46566 swig_obj[0] = args;
46567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46568 if (!SWIG_IsOK(res1)) {
46569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46570 }
46571 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46572 {
46573 PyThreadState* __tstate = wxPyBeginAllowThreads();
46574 result = (arg1)->GetSize();
46575 wxPyEndAllowThreads(__tstate);
46576 if (PyErr_Occurred()) SWIG_fail;
46577 }
46578 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46579 return resultobj;
46580 fail:
46581 return NULL;
46582 }
46583
46584
46585 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46586 PyObject *resultobj = 0;
46587 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46588 wxSize result;
46589 void *argp1 = 0 ;
46590 int res1 = 0 ;
46591 PyObject *swig_obj[1] ;
46592
46593 if (!args) SWIG_fail;
46594 swig_obj[0] = args;
46595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46596 if (!SWIG_IsOK(res1)) {
46597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46598 }
46599 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46600 {
46601 PyThreadState* __tstate = wxPyBeginAllowThreads();
46602 result = (arg1)->CalcMin();
46603 wxPyEndAllowThreads(__tstate);
46604 if (PyErr_Occurred()) SWIG_fail;
46605 }
46606 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46607 return resultobj;
46608 fail:
46609 return NULL;
46610 }
46611
46612
46613 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46614 PyObject *resultobj = 0;
46615 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46616 wxPoint *arg2 = 0 ;
46617 wxSize *arg3 = 0 ;
46618 void *argp1 = 0 ;
46619 int res1 = 0 ;
46620 wxPoint temp2 ;
46621 wxSize temp3 ;
46622 PyObject * obj0 = 0 ;
46623 PyObject * obj1 = 0 ;
46624 PyObject * obj2 = 0 ;
46625 char * kwnames[] = {
46626 (char *) "self",(char *) "pos",(char *) "size", NULL
46627 };
46628
46629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46631 if (!SWIG_IsOK(res1)) {
46632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46633 }
46634 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46635 {
46636 arg2 = &temp2;
46637 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46638 }
46639 {
46640 arg3 = &temp3;
46641 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46642 }
46643 {
46644 PyThreadState* __tstate = wxPyBeginAllowThreads();
46645 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46646 wxPyEndAllowThreads(__tstate);
46647 if (PyErr_Occurred()) SWIG_fail;
46648 }
46649 resultobj = SWIG_Py_Void();
46650 return resultobj;
46651 fail:
46652 return NULL;
46653 }
46654
46655
46656 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46657 PyObject *resultobj = 0;
46658 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46659 wxSize result;
46660 void *argp1 = 0 ;
46661 int res1 = 0 ;
46662 PyObject *swig_obj[1] ;
46663
46664 if (!args) SWIG_fail;
46665 swig_obj[0] = args;
46666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46667 if (!SWIG_IsOK(res1)) {
46668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46669 }
46670 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46671 {
46672 PyThreadState* __tstate = wxPyBeginAllowThreads();
46673 result = (arg1)->GetMinSize();
46674 wxPyEndAllowThreads(__tstate);
46675 if (PyErr_Occurred()) SWIG_fail;
46676 }
46677 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46678 return resultobj;
46679 fail:
46680 return NULL;
46681 }
46682
46683
46684 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46685 PyObject *resultobj = 0;
46686 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46687 wxSize result;
46688 void *argp1 = 0 ;
46689 int res1 = 0 ;
46690 PyObject *swig_obj[1] ;
46691
46692 if (!args) SWIG_fail;
46693 swig_obj[0] = args;
46694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46695 if (!SWIG_IsOK(res1)) {
46696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46697 }
46698 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46699 {
46700 PyThreadState* __tstate = wxPyBeginAllowThreads();
46701 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46702 wxPyEndAllowThreads(__tstate);
46703 if (PyErr_Occurred()) SWIG_fail;
46704 }
46705 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46706 return resultobj;
46707 fail:
46708 return NULL;
46709 }
46710
46711
46712 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46713 PyObject *resultobj = 0;
46714 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46715 int arg2 ;
46716 int arg3 ;
46717 void *argp1 = 0 ;
46718 int res1 = 0 ;
46719 int val2 ;
46720 int ecode2 = 0 ;
46721 int val3 ;
46722 int ecode3 = 0 ;
46723 PyObject * obj0 = 0 ;
46724 PyObject * obj1 = 0 ;
46725 PyObject * obj2 = 0 ;
46726 char * kwnames[] = {
46727 (char *) "self",(char *) "x",(char *) "y", NULL
46728 };
46729
46730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46732 if (!SWIG_IsOK(res1)) {
46733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46734 }
46735 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46736 ecode2 = SWIG_AsVal_int(obj1, &val2);
46737 if (!SWIG_IsOK(ecode2)) {
46738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46739 }
46740 arg2 = static_cast< int >(val2);
46741 ecode3 = SWIG_AsVal_int(obj2, &val3);
46742 if (!SWIG_IsOK(ecode3)) {
46743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46744 }
46745 arg3 = static_cast< int >(val3);
46746 {
46747 PyThreadState* __tstate = wxPyBeginAllowThreads();
46748 (arg1)->SetInitSize(arg2,arg3);
46749 wxPyEndAllowThreads(__tstate);
46750 if (PyErr_Occurred()) SWIG_fail;
46751 }
46752 resultobj = SWIG_Py_Void();
46753 return resultobj;
46754 fail:
46755 return NULL;
46756 }
46757
46758
46759 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46760 PyObject *resultobj = 0;
46761 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46762 int arg2 ;
46763 int arg3 ;
46764 void *argp1 = 0 ;
46765 int res1 = 0 ;
46766 int val2 ;
46767 int ecode2 = 0 ;
46768 int val3 ;
46769 int ecode3 = 0 ;
46770 PyObject * obj0 = 0 ;
46771 PyObject * obj1 = 0 ;
46772 PyObject * obj2 = 0 ;
46773 char * kwnames[] = {
46774 (char *) "self",(char *) "width",(char *) "height", NULL
46775 };
46776
46777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46779 if (!SWIG_IsOK(res1)) {
46780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46781 }
46782 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46783 ecode2 = SWIG_AsVal_int(obj1, &val2);
46784 if (!SWIG_IsOK(ecode2)) {
46785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46786 }
46787 arg2 = static_cast< int >(val2);
46788 ecode3 = SWIG_AsVal_int(obj2, &val3);
46789 if (!SWIG_IsOK(ecode3)) {
46790 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46791 }
46792 arg3 = static_cast< int >(val3);
46793 {
46794 PyThreadState* __tstate = wxPyBeginAllowThreads();
46795 (arg1)->SetRatio(arg2,arg3);
46796 wxPyEndAllowThreads(__tstate);
46797 if (PyErr_Occurred()) SWIG_fail;
46798 }
46799 resultobj = SWIG_Py_Void();
46800 return resultobj;
46801 fail:
46802 return NULL;
46803 }
46804
46805
46806 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46807 PyObject *resultobj = 0;
46808 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46809 wxSize *arg2 = 0 ;
46810 void *argp1 = 0 ;
46811 int res1 = 0 ;
46812 wxSize temp2 ;
46813 PyObject * obj0 = 0 ;
46814 PyObject * obj1 = 0 ;
46815 char * kwnames[] = {
46816 (char *) "self",(char *) "size", NULL
46817 };
46818
46819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46821 if (!SWIG_IsOK(res1)) {
46822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46823 }
46824 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46825 {
46826 arg2 = &temp2;
46827 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46828 }
46829 {
46830 PyThreadState* __tstate = wxPyBeginAllowThreads();
46831 (arg1)->SetRatio((wxSize const &)*arg2);
46832 wxPyEndAllowThreads(__tstate);
46833 if (PyErr_Occurred()) SWIG_fail;
46834 }
46835 resultobj = SWIG_Py_Void();
46836 return resultobj;
46837 fail:
46838 return NULL;
46839 }
46840
46841
46842 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46843 PyObject *resultobj = 0;
46844 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46845 float arg2 ;
46846 void *argp1 = 0 ;
46847 int res1 = 0 ;
46848 float val2 ;
46849 int ecode2 = 0 ;
46850 PyObject * obj0 = 0 ;
46851 PyObject * obj1 = 0 ;
46852 char * kwnames[] = {
46853 (char *) "self",(char *) "ratio", NULL
46854 };
46855
46856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46858 if (!SWIG_IsOK(res1)) {
46859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46860 }
46861 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46862 ecode2 = SWIG_AsVal_float(obj1, &val2);
46863 if (!SWIG_IsOK(ecode2)) {
46864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46865 }
46866 arg2 = static_cast< float >(val2);
46867 {
46868 PyThreadState* __tstate = wxPyBeginAllowThreads();
46869 (arg1)->SetRatio(arg2);
46870 wxPyEndAllowThreads(__tstate);
46871 if (PyErr_Occurred()) SWIG_fail;
46872 }
46873 resultobj = SWIG_Py_Void();
46874 return resultobj;
46875 fail:
46876 return NULL;
46877 }
46878
46879
46880 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46881 PyObject *resultobj = 0;
46882 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46883 float result;
46884 void *argp1 = 0 ;
46885 int res1 = 0 ;
46886 PyObject *swig_obj[1] ;
46887
46888 if (!args) SWIG_fail;
46889 swig_obj[0] = args;
46890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46891 if (!SWIG_IsOK(res1)) {
46892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46893 }
46894 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46895 {
46896 PyThreadState* __tstate = wxPyBeginAllowThreads();
46897 result = (float)(arg1)->GetRatio();
46898 wxPyEndAllowThreads(__tstate);
46899 if (PyErr_Occurred()) SWIG_fail;
46900 }
46901 resultobj = SWIG_From_float(static_cast< float >(result));
46902 return resultobj;
46903 fail:
46904 return NULL;
46905 }
46906
46907
46908 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46909 PyObject *resultobj = 0;
46910 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46911 wxRect result;
46912 void *argp1 = 0 ;
46913 int res1 = 0 ;
46914 PyObject *swig_obj[1] ;
46915
46916 if (!args) SWIG_fail;
46917 swig_obj[0] = args;
46918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46919 if (!SWIG_IsOK(res1)) {
46920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46921 }
46922 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46923 {
46924 PyThreadState* __tstate = wxPyBeginAllowThreads();
46925 result = (arg1)->GetRect();
46926 wxPyEndAllowThreads(__tstate);
46927 if (PyErr_Occurred()) SWIG_fail;
46928 }
46929 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46930 return resultobj;
46931 fail:
46932 return NULL;
46933 }
46934
46935
46936 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46937 PyObject *resultobj = 0;
46938 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46939 bool result;
46940 void *argp1 = 0 ;
46941 int res1 = 0 ;
46942 PyObject *swig_obj[1] ;
46943
46944 if (!args) SWIG_fail;
46945 swig_obj[0] = args;
46946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46947 if (!SWIG_IsOK(res1)) {
46948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46949 }
46950 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46951 {
46952 PyThreadState* __tstate = wxPyBeginAllowThreads();
46953 result = (bool)(arg1)->IsWindow();
46954 wxPyEndAllowThreads(__tstate);
46955 if (PyErr_Occurred()) SWIG_fail;
46956 }
46957 {
46958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46959 }
46960 return resultobj;
46961 fail:
46962 return NULL;
46963 }
46964
46965
46966 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46967 PyObject *resultobj = 0;
46968 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46969 bool result;
46970 void *argp1 = 0 ;
46971 int res1 = 0 ;
46972 PyObject *swig_obj[1] ;
46973
46974 if (!args) SWIG_fail;
46975 swig_obj[0] = args;
46976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46977 if (!SWIG_IsOK(res1)) {
46978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46979 }
46980 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46981 {
46982 PyThreadState* __tstate = wxPyBeginAllowThreads();
46983 result = (bool)(arg1)->IsSizer();
46984 wxPyEndAllowThreads(__tstate);
46985 if (PyErr_Occurred()) SWIG_fail;
46986 }
46987 {
46988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46989 }
46990 return resultobj;
46991 fail:
46992 return NULL;
46993 }
46994
46995
46996 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46997 PyObject *resultobj = 0;
46998 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46999 bool result;
47000 void *argp1 = 0 ;
47001 int res1 = 0 ;
47002 PyObject *swig_obj[1] ;
47003
47004 if (!args) SWIG_fail;
47005 swig_obj[0] = args;
47006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47007 if (!SWIG_IsOK(res1)) {
47008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47009 }
47010 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47011 {
47012 PyThreadState* __tstate = wxPyBeginAllowThreads();
47013 result = (bool)(arg1)->IsSpacer();
47014 wxPyEndAllowThreads(__tstate);
47015 if (PyErr_Occurred()) SWIG_fail;
47016 }
47017 {
47018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47019 }
47020 return resultobj;
47021 fail:
47022 return NULL;
47023 }
47024
47025
47026 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47027 PyObject *resultobj = 0;
47028 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47029 int arg2 ;
47030 void *argp1 = 0 ;
47031 int res1 = 0 ;
47032 int val2 ;
47033 int ecode2 = 0 ;
47034 PyObject * obj0 = 0 ;
47035 PyObject * obj1 = 0 ;
47036 char * kwnames[] = {
47037 (char *) "self",(char *) "proportion", NULL
47038 };
47039
47040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
47041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47042 if (!SWIG_IsOK(res1)) {
47043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47044 }
47045 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47046 ecode2 = SWIG_AsVal_int(obj1, &val2);
47047 if (!SWIG_IsOK(ecode2)) {
47048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
47049 }
47050 arg2 = static_cast< int >(val2);
47051 {
47052 PyThreadState* __tstate = wxPyBeginAllowThreads();
47053 (arg1)->SetProportion(arg2);
47054 wxPyEndAllowThreads(__tstate);
47055 if (PyErr_Occurred()) SWIG_fail;
47056 }
47057 resultobj = SWIG_Py_Void();
47058 return resultobj;
47059 fail:
47060 return NULL;
47061 }
47062
47063
47064 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47065 PyObject *resultobj = 0;
47066 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47067 int result;
47068 void *argp1 = 0 ;
47069 int res1 = 0 ;
47070 PyObject *swig_obj[1] ;
47071
47072 if (!args) SWIG_fail;
47073 swig_obj[0] = args;
47074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47075 if (!SWIG_IsOK(res1)) {
47076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47077 }
47078 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47079 {
47080 PyThreadState* __tstate = wxPyBeginAllowThreads();
47081 result = (int)(arg1)->GetProportion();
47082 wxPyEndAllowThreads(__tstate);
47083 if (PyErr_Occurred()) SWIG_fail;
47084 }
47085 resultobj = SWIG_From_int(static_cast< int >(result));
47086 return resultobj;
47087 fail:
47088 return NULL;
47089 }
47090
47091
47092 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47093 PyObject *resultobj = 0;
47094 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47095 int arg2 ;
47096 void *argp1 = 0 ;
47097 int res1 = 0 ;
47098 int val2 ;
47099 int ecode2 = 0 ;
47100 PyObject * obj0 = 0 ;
47101 PyObject * obj1 = 0 ;
47102 char * kwnames[] = {
47103 (char *) "self",(char *) "flag", NULL
47104 };
47105
47106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
47107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47108 if (!SWIG_IsOK(res1)) {
47109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47110 }
47111 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47112 ecode2 = SWIG_AsVal_int(obj1, &val2);
47113 if (!SWIG_IsOK(ecode2)) {
47114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
47115 }
47116 arg2 = static_cast< int >(val2);
47117 {
47118 PyThreadState* __tstate = wxPyBeginAllowThreads();
47119 (arg1)->SetFlag(arg2);
47120 wxPyEndAllowThreads(__tstate);
47121 if (PyErr_Occurred()) SWIG_fail;
47122 }
47123 resultobj = SWIG_Py_Void();
47124 return resultobj;
47125 fail:
47126 return NULL;
47127 }
47128
47129
47130 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47131 PyObject *resultobj = 0;
47132 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47133 int result;
47134 void *argp1 = 0 ;
47135 int res1 = 0 ;
47136 PyObject *swig_obj[1] ;
47137
47138 if (!args) SWIG_fail;
47139 swig_obj[0] = args;
47140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47141 if (!SWIG_IsOK(res1)) {
47142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47143 }
47144 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47145 {
47146 PyThreadState* __tstate = wxPyBeginAllowThreads();
47147 result = (int)(arg1)->GetFlag();
47148 wxPyEndAllowThreads(__tstate);
47149 if (PyErr_Occurred()) SWIG_fail;
47150 }
47151 resultobj = SWIG_From_int(static_cast< int >(result));
47152 return resultobj;
47153 fail:
47154 return NULL;
47155 }
47156
47157
47158 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47159 PyObject *resultobj = 0;
47160 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47161 int arg2 ;
47162 void *argp1 = 0 ;
47163 int res1 = 0 ;
47164 int val2 ;
47165 int ecode2 = 0 ;
47166 PyObject * obj0 = 0 ;
47167 PyObject * obj1 = 0 ;
47168 char * kwnames[] = {
47169 (char *) "self",(char *) "border", NULL
47170 };
47171
47172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
47173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47174 if (!SWIG_IsOK(res1)) {
47175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47176 }
47177 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47178 ecode2 = SWIG_AsVal_int(obj1, &val2);
47179 if (!SWIG_IsOK(ecode2)) {
47180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
47181 }
47182 arg2 = static_cast< int >(val2);
47183 {
47184 PyThreadState* __tstate = wxPyBeginAllowThreads();
47185 (arg1)->SetBorder(arg2);
47186 wxPyEndAllowThreads(__tstate);
47187 if (PyErr_Occurred()) SWIG_fail;
47188 }
47189 resultobj = SWIG_Py_Void();
47190 return resultobj;
47191 fail:
47192 return NULL;
47193 }
47194
47195
47196 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47197 PyObject *resultobj = 0;
47198 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47199 int result;
47200 void *argp1 = 0 ;
47201 int res1 = 0 ;
47202 PyObject *swig_obj[1] ;
47203
47204 if (!args) SWIG_fail;
47205 swig_obj[0] = args;
47206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47207 if (!SWIG_IsOK(res1)) {
47208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47209 }
47210 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47211 {
47212 PyThreadState* __tstate = wxPyBeginAllowThreads();
47213 result = (int)(arg1)->GetBorder();
47214 wxPyEndAllowThreads(__tstate);
47215 if (PyErr_Occurred()) SWIG_fail;
47216 }
47217 resultobj = SWIG_From_int(static_cast< int >(result));
47218 return resultobj;
47219 fail:
47220 return NULL;
47221 }
47222
47223
47224 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47225 PyObject *resultobj = 0;
47226 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47227 wxWindow *result = 0 ;
47228 void *argp1 = 0 ;
47229 int res1 = 0 ;
47230 PyObject *swig_obj[1] ;
47231
47232 if (!args) SWIG_fail;
47233 swig_obj[0] = args;
47234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47235 if (!SWIG_IsOK(res1)) {
47236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47237 }
47238 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47239 {
47240 PyThreadState* __tstate = wxPyBeginAllowThreads();
47241 result = (wxWindow *)(arg1)->GetWindow();
47242 wxPyEndAllowThreads(__tstate);
47243 if (PyErr_Occurred()) SWIG_fail;
47244 }
47245 {
47246 resultobj = wxPyMake_wxObject(result, 0);
47247 }
47248 return resultobj;
47249 fail:
47250 return NULL;
47251 }
47252
47253
47254 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47255 PyObject *resultobj = 0;
47256 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47257 wxWindow *arg2 = (wxWindow *) 0 ;
47258 void *argp1 = 0 ;
47259 int res1 = 0 ;
47260 void *argp2 = 0 ;
47261 int res2 = 0 ;
47262 PyObject * obj0 = 0 ;
47263 PyObject * obj1 = 0 ;
47264 char * kwnames[] = {
47265 (char *) "self",(char *) "window", NULL
47266 };
47267
47268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47270 if (!SWIG_IsOK(res1)) {
47271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47272 }
47273 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47274 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47275 if (!SWIG_IsOK(res2)) {
47276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47277 }
47278 arg2 = reinterpret_cast< wxWindow * >(argp2);
47279 {
47280 PyThreadState* __tstate = wxPyBeginAllowThreads();
47281 (arg1)->SetWindow(arg2);
47282 wxPyEndAllowThreads(__tstate);
47283 if (PyErr_Occurred()) SWIG_fail;
47284 }
47285 resultobj = SWIG_Py_Void();
47286 return resultobj;
47287 fail:
47288 return NULL;
47289 }
47290
47291
47292 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47293 PyObject *resultobj = 0;
47294 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47295 wxSizer *result = 0 ;
47296 void *argp1 = 0 ;
47297 int res1 = 0 ;
47298 PyObject *swig_obj[1] ;
47299
47300 if (!args) SWIG_fail;
47301 swig_obj[0] = args;
47302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47303 if (!SWIG_IsOK(res1)) {
47304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47305 }
47306 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47307 {
47308 PyThreadState* __tstate = wxPyBeginAllowThreads();
47309 result = (wxSizer *)(arg1)->GetSizer();
47310 wxPyEndAllowThreads(__tstate);
47311 if (PyErr_Occurred()) SWIG_fail;
47312 }
47313 {
47314 resultobj = wxPyMake_wxObject(result, (bool)0);
47315 }
47316 return resultobj;
47317 fail:
47318 return NULL;
47319 }
47320
47321
47322 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47323 PyObject *resultobj = 0;
47324 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47325 wxSizer *arg2 = (wxSizer *) 0 ;
47326 void *argp1 = 0 ;
47327 int res1 = 0 ;
47328 int res2 = 0 ;
47329 PyObject * obj0 = 0 ;
47330 PyObject * obj1 = 0 ;
47331 char * kwnames[] = {
47332 (char *) "self",(char *) "sizer", NULL
47333 };
47334
47335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47337 if (!SWIG_IsOK(res1)) {
47338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47339 }
47340 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47341 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47342 if (!SWIG_IsOK(res2)) {
47343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47344 }
47345 {
47346 PyThreadState* __tstate = wxPyBeginAllowThreads();
47347 (arg1)->SetSizer(arg2);
47348 wxPyEndAllowThreads(__tstate);
47349 if (PyErr_Occurred()) SWIG_fail;
47350 }
47351 resultobj = SWIG_Py_Void();
47352 return resultobj;
47353 fail:
47354 return NULL;
47355 }
47356
47357
47358 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47359 PyObject *resultobj = 0;
47360 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47361 wxSize result;
47362 void *argp1 = 0 ;
47363 int res1 = 0 ;
47364 PyObject *swig_obj[1] ;
47365
47366 if (!args) SWIG_fail;
47367 swig_obj[0] = args;
47368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47369 if (!SWIG_IsOK(res1)) {
47370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47371 }
47372 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47373 {
47374 PyThreadState* __tstate = wxPyBeginAllowThreads();
47375 result = (arg1)->GetSpacer();
47376 wxPyEndAllowThreads(__tstate);
47377 if (PyErr_Occurred()) SWIG_fail;
47378 }
47379 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47380 return resultobj;
47381 fail:
47382 return NULL;
47383 }
47384
47385
47386 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47387 PyObject *resultobj = 0;
47388 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47389 wxSize *arg2 = 0 ;
47390 void *argp1 = 0 ;
47391 int res1 = 0 ;
47392 wxSize temp2 ;
47393 PyObject * obj0 = 0 ;
47394 PyObject * obj1 = 0 ;
47395 char * kwnames[] = {
47396 (char *) "self",(char *) "size", NULL
47397 };
47398
47399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
47400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47401 if (!SWIG_IsOK(res1)) {
47402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47403 }
47404 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47405 {
47406 arg2 = &temp2;
47407 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47408 }
47409 {
47410 PyThreadState* __tstate = wxPyBeginAllowThreads();
47411 (arg1)->SetSpacer((wxSize const &)*arg2);
47412 wxPyEndAllowThreads(__tstate);
47413 if (PyErr_Occurred()) SWIG_fail;
47414 }
47415 resultobj = SWIG_Py_Void();
47416 return resultobj;
47417 fail:
47418 return NULL;
47419 }
47420
47421
47422 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47423 PyObject *resultobj = 0;
47424 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47425 bool arg2 ;
47426 void *argp1 = 0 ;
47427 int res1 = 0 ;
47428 bool val2 ;
47429 int ecode2 = 0 ;
47430 PyObject * obj0 = 0 ;
47431 PyObject * obj1 = 0 ;
47432 char * kwnames[] = {
47433 (char *) "self",(char *) "show", NULL
47434 };
47435
47436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
47437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47438 if (!SWIG_IsOK(res1)) {
47439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47440 }
47441 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47442 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47443 if (!SWIG_IsOK(ecode2)) {
47444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
47445 }
47446 arg2 = static_cast< bool >(val2);
47447 {
47448 PyThreadState* __tstate = wxPyBeginAllowThreads();
47449 (arg1)->Show(arg2);
47450 wxPyEndAllowThreads(__tstate);
47451 if (PyErr_Occurred()) SWIG_fail;
47452 }
47453 resultobj = SWIG_Py_Void();
47454 return resultobj;
47455 fail:
47456 return NULL;
47457 }
47458
47459
47460 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47461 PyObject *resultobj = 0;
47462 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47463 bool result;
47464 void *argp1 = 0 ;
47465 int res1 = 0 ;
47466 PyObject *swig_obj[1] ;
47467
47468 if (!args) SWIG_fail;
47469 swig_obj[0] = args;
47470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47471 if (!SWIG_IsOK(res1)) {
47472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47473 }
47474 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47475 {
47476 PyThreadState* __tstate = wxPyBeginAllowThreads();
47477 result = (bool)(arg1)->IsShown();
47478 wxPyEndAllowThreads(__tstate);
47479 if (PyErr_Occurred()) SWIG_fail;
47480 }
47481 {
47482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47483 }
47484 return resultobj;
47485 fail:
47486 return NULL;
47487 }
47488
47489
47490 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47491 PyObject *resultobj = 0;
47492 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47493 wxPoint result;
47494 void *argp1 = 0 ;
47495 int res1 = 0 ;
47496 PyObject *swig_obj[1] ;
47497
47498 if (!args) SWIG_fail;
47499 swig_obj[0] = args;
47500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47501 if (!SWIG_IsOK(res1)) {
47502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47503 }
47504 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47505 {
47506 PyThreadState* __tstate = wxPyBeginAllowThreads();
47507 result = (arg1)->GetPosition();
47508 wxPyEndAllowThreads(__tstate);
47509 if (PyErr_Occurred()) SWIG_fail;
47510 }
47511 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47512 return resultobj;
47513 fail:
47514 return NULL;
47515 }
47516
47517
47518 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47519 PyObject *resultobj = 0;
47520 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47521 PyObject *result = 0 ;
47522 void *argp1 = 0 ;
47523 int res1 = 0 ;
47524 PyObject *swig_obj[1] ;
47525
47526 if (!args) SWIG_fail;
47527 swig_obj[0] = args;
47528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47529 if (!SWIG_IsOK(res1)) {
47530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47531 }
47532 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47533 {
47534 PyThreadState* __tstate = wxPyBeginAllowThreads();
47535 result = (PyObject *)wxSizerItem_GetUserData(arg1);
47536 wxPyEndAllowThreads(__tstate);
47537 if (PyErr_Occurred()) SWIG_fail;
47538 }
47539 resultobj = result;
47540 return resultobj;
47541 fail:
47542 return NULL;
47543 }
47544
47545
47546 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47547 PyObject *resultobj = 0;
47548 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47549 PyObject *arg2 = (PyObject *) 0 ;
47550 void *argp1 = 0 ;
47551 int res1 = 0 ;
47552 PyObject * obj0 = 0 ;
47553 PyObject * obj1 = 0 ;
47554 char * kwnames[] = {
47555 (char *) "self",(char *) "userData", NULL
47556 };
47557
47558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47560 if (!SWIG_IsOK(res1)) {
47561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47562 }
47563 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47564 arg2 = obj1;
47565 {
47566 PyThreadState* __tstate = wxPyBeginAllowThreads();
47567 wxSizerItem_SetUserData(arg1,arg2);
47568 wxPyEndAllowThreads(__tstate);
47569 if (PyErr_Occurred()) SWIG_fail;
47570 }
47571 resultobj = SWIG_Py_Void();
47572 return resultobj;
47573 fail:
47574 return NULL;
47575 }
47576
47577
47578 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47579 PyObject *obj;
47580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47581 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47582 return SWIG_Py_Void();
47583 }
47584
47585 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47586 return SWIG_Python_InitShadowInstance(args);
47587 }
47588
47589 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47590 PyObject *resultobj = 0;
47591 wxSizer *arg1 = (wxSizer *) 0 ;
47592 void *argp1 = 0 ;
47593 int res1 = 0 ;
47594 PyObject *swig_obj[1] ;
47595
47596 if (!args) SWIG_fail;
47597 swig_obj[0] = args;
47598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47599 if (!SWIG_IsOK(res1)) {
47600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47601 }
47602 arg1 = reinterpret_cast< wxSizer * >(argp1);
47603 {
47604 PyThreadState* __tstate = wxPyBeginAllowThreads();
47605 delete arg1;
47606
47607 wxPyEndAllowThreads(__tstate);
47608 if (PyErr_Occurred()) SWIG_fail;
47609 }
47610 resultobj = SWIG_Py_Void();
47611 return resultobj;
47612 fail:
47613 return NULL;
47614 }
47615
47616
47617 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47618 PyObject *resultobj = 0;
47619 wxSizer *arg1 = (wxSizer *) 0 ;
47620 PyObject *arg2 = (PyObject *) 0 ;
47621 void *argp1 = 0 ;
47622 int res1 = 0 ;
47623 PyObject * obj0 = 0 ;
47624 PyObject * obj1 = 0 ;
47625 char * kwnames[] = {
47626 (char *) "self",(char *) "_self", NULL
47627 };
47628
47629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47631 if (!SWIG_IsOK(res1)) {
47632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47633 }
47634 arg1 = reinterpret_cast< wxSizer * >(argp1);
47635 arg2 = obj1;
47636 {
47637 PyThreadState* __tstate = wxPyBeginAllowThreads();
47638 wxSizer__setOORInfo(arg1,arg2);
47639 wxPyEndAllowThreads(__tstate);
47640 if (PyErr_Occurred()) SWIG_fail;
47641 }
47642 resultobj = SWIG_Py_Void();
47643 return resultobj;
47644 fail:
47645 return NULL;
47646 }
47647
47648
47649 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47650 PyObject *resultobj = 0;
47651 wxSizer *arg1 = (wxSizer *) 0 ;
47652 PyObject *arg2 = (PyObject *) 0 ;
47653 int arg3 = (int) 0 ;
47654 int arg4 = (int) 0 ;
47655 int arg5 = (int) 0 ;
47656 PyObject *arg6 = (PyObject *) NULL ;
47657 wxSizerItem *result = 0 ;
47658 void *argp1 = 0 ;
47659 int res1 = 0 ;
47660 int val3 ;
47661 int ecode3 = 0 ;
47662 int val4 ;
47663 int ecode4 = 0 ;
47664 int val5 ;
47665 int ecode5 = 0 ;
47666 PyObject * obj0 = 0 ;
47667 PyObject * obj1 = 0 ;
47668 PyObject * obj2 = 0 ;
47669 PyObject * obj3 = 0 ;
47670 PyObject * obj4 = 0 ;
47671 PyObject * obj5 = 0 ;
47672 char * kwnames[] = {
47673 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47674 };
47675
47676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47678 if (!SWIG_IsOK(res1)) {
47679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47680 }
47681 arg1 = reinterpret_cast< wxSizer * >(argp1);
47682 arg2 = obj1;
47683 if (obj2) {
47684 ecode3 = SWIG_AsVal_int(obj2, &val3);
47685 if (!SWIG_IsOK(ecode3)) {
47686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47687 }
47688 arg3 = static_cast< int >(val3);
47689 }
47690 if (obj3) {
47691 ecode4 = SWIG_AsVal_int(obj3, &val4);
47692 if (!SWIG_IsOK(ecode4)) {
47693 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47694 }
47695 arg4 = static_cast< int >(val4);
47696 }
47697 if (obj4) {
47698 ecode5 = SWIG_AsVal_int(obj4, &val5);
47699 if (!SWIG_IsOK(ecode5)) {
47700 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47701 }
47702 arg5 = static_cast< int >(val5);
47703 }
47704 if (obj5) {
47705 arg6 = obj5;
47706 }
47707 {
47708 PyThreadState* __tstate = wxPyBeginAllowThreads();
47709 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47710 wxPyEndAllowThreads(__tstate);
47711 if (PyErr_Occurred()) SWIG_fail;
47712 }
47713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47714 return resultobj;
47715 fail:
47716 return NULL;
47717 }
47718
47719
47720 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47721 PyObject *resultobj = 0;
47722 wxSizer *arg1 = (wxSizer *) 0 ;
47723 int arg2 ;
47724 PyObject *arg3 = (PyObject *) 0 ;
47725 int arg4 = (int) 0 ;
47726 int arg5 = (int) 0 ;
47727 int arg6 = (int) 0 ;
47728 PyObject *arg7 = (PyObject *) NULL ;
47729 wxSizerItem *result = 0 ;
47730 void *argp1 = 0 ;
47731 int res1 = 0 ;
47732 int val2 ;
47733 int ecode2 = 0 ;
47734 int val4 ;
47735 int ecode4 = 0 ;
47736 int val5 ;
47737 int ecode5 = 0 ;
47738 int val6 ;
47739 int ecode6 = 0 ;
47740 PyObject * obj0 = 0 ;
47741 PyObject * obj1 = 0 ;
47742 PyObject * obj2 = 0 ;
47743 PyObject * obj3 = 0 ;
47744 PyObject * obj4 = 0 ;
47745 PyObject * obj5 = 0 ;
47746 PyObject * obj6 = 0 ;
47747 char * kwnames[] = {
47748 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47749 };
47750
47751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47753 if (!SWIG_IsOK(res1)) {
47754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47755 }
47756 arg1 = reinterpret_cast< wxSizer * >(argp1);
47757 ecode2 = SWIG_AsVal_int(obj1, &val2);
47758 if (!SWIG_IsOK(ecode2)) {
47759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47760 }
47761 arg2 = static_cast< int >(val2);
47762 arg3 = obj2;
47763 if (obj3) {
47764 ecode4 = SWIG_AsVal_int(obj3, &val4);
47765 if (!SWIG_IsOK(ecode4)) {
47766 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47767 }
47768 arg4 = static_cast< int >(val4);
47769 }
47770 if (obj4) {
47771 ecode5 = SWIG_AsVal_int(obj4, &val5);
47772 if (!SWIG_IsOK(ecode5)) {
47773 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47774 }
47775 arg5 = static_cast< int >(val5);
47776 }
47777 if (obj5) {
47778 ecode6 = SWIG_AsVal_int(obj5, &val6);
47779 if (!SWIG_IsOK(ecode6)) {
47780 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47781 }
47782 arg6 = static_cast< int >(val6);
47783 }
47784 if (obj6) {
47785 arg7 = obj6;
47786 }
47787 {
47788 PyThreadState* __tstate = wxPyBeginAllowThreads();
47789 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47790 wxPyEndAllowThreads(__tstate);
47791 if (PyErr_Occurred()) SWIG_fail;
47792 }
47793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47794 return resultobj;
47795 fail:
47796 return NULL;
47797 }
47798
47799
47800 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47801 PyObject *resultobj = 0;
47802 wxSizer *arg1 = (wxSizer *) 0 ;
47803 PyObject *arg2 = (PyObject *) 0 ;
47804 int arg3 = (int) 0 ;
47805 int arg4 = (int) 0 ;
47806 int arg5 = (int) 0 ;
47807 PyObject *arg6 = (PyObject *) NULL ;
47808 wxSizerItem *result = 0 ;
47809 void *argp1 = 0 ;
47810 int res1 = 0 ;
47811 int val3 ;
47812 int ecode3 = 0 ;
47813 int val4 ;
47814 int ecode4 = 0 ;
47815 int val5 ;
47816 int ecode5 = 0 ;
47817 PyObject * obj0 = 0 ;
47818 PyObject * obj1 = 0 ;
47819 PyObject * obj2 = 0 ;
47820 PyObject * obj3 = 0 ;
47821 PyObject * obj4 = 0 ;
47822 PyObject * obj5 = 0 ;
47823 char * kwnames[] = {
47824 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47825 };
47826
47827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47829 if (!SWIG_IsOK(res1)) {
47830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47831 }
47832 arg1 = reinterpret_cast< wxSizer * >(argp1);
47833 arg2 = obj1;
47834 if (obj2) {
47835 ecode3 = SWIG_AsVal_int(obj2, &val3);
47836 if (!SWIG_IsOK(ecode3)) {
47837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47838 }
47839 arg3 = static_cast< int >(val3);
47840 }
47841 if (obj3) {
47842 ecode4 = SWIG_AsVal_int(obj3, &val4);
47843 if (!SWIG_IsOK(ecode4)) {
47844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47845 }
47846 arg4 = static_cast< int >(val4);
47847 }
47848 if (obj4) {
47849 ecode5 = SWIG_AsVal_int(obj4, &val5);
47850 if (!SWIG_IsOK(ecode5)) {
47851 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47852 }
47853 arg5 = static_cast< int >(val5);
47854 }
47855 if (obj5) {
47856 arg6 = obj5;
47857 }
47858 {
47859 PyThreadState* __tstate = wxPyBeginAllowThreads();
47860 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47861 wxPyEndAllowThreads(__tstate);
47862 if (PyErr_Occurred()) SWIG_fail;
47863 }
47864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47865 return resultobj;
47866 fail:
47867 return NULL;
47868 }
47869
47870
47871 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47872 PyObject *resultobj = 0;
47873 wxSizer *arg1 = (wxSizer *) 0 ;
47874 PyObject *arg2 = (PyObject *) 0 ;
47875 bool result;
47876 void *argp1 = 0 ;
47877 int res1 = 0 ;
47878 PyObject * obj0 = 0 ;
47879 PyObject * obj1 = 0 ;
47880 char * kwnames[] = {
47881 (char *) "self",(char *) "item", NULL
47882 };
47883
47884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47886 if (!SWIG_IsOK(res1)) {
47887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47888 }
47889 arg1 = reinterpret_cast< wxSizer * >(argp1);
47890 arg2 = obj1;
47891 {
47892 PyThreadState* __tstate = wxPyBeginAllowThreads();
47893 result = (bool)wxSizer_Remove(arg1,arg2);
47894 wxPyEndAllowThreads(__tstate);
47895 if (PyErr_Occurred()) SWIG_fail;
47896 }
47897 {
47898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47899 }
47900 return resultobj;
47901 fail:
47902 return NULL;
47903 }
47904
47905
47906 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47907 PyObject *resultobj = 0;
47908 wxSizer *arg1 = (wxSizer *) 0 ;
47909 PyObject *arg2 = (PyObject *) 0 ;
47910 bool result;
47911 void *argp1 = 0 ;
47912 int res1 = 0 ;
47913 PyObject * obj0 = 0 ;
47914 PyObject * obj1 = 0 ;
47915 char * kwnames[] = {
47916 (char *) "self",(char *) "item", NULL
47917 };
47918
47919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47921 if (!SWIG_IsOK(res1)) {
47922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47923 }
47924 arg1 = reinterpret_cast< wxSizer * >(argp1);
47925 arg2 = obj1;
47926 {
47927 PyThreadState* __tstate = wxPyBeginAllowThreads();
47928 result = (bool)wxSizer_Detach(arg1,arg2);
47929 wxPyEndAllowThreads(__tstate);
47930 if (PyErr_Occurred()) SWIG_fail;
47931 }
47932 {
47933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47934 }
47935 return resultobj;
47936 fail:
47937 return NULL;
47938 }
47939
47940
47941 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47942 PyObject *resultobj = 0;
47943 wxSizer *arg1 = (wxSizer *) 0 ;
47944 PyObject *arg2 = (PyObject *) 0 ;
47945 wxSizerItem *result = 0 ;
47946 void *argp1 = 0 ;
47947 int res1 = 0 ;
47948 PyObject * obj0 = 0 ;
47949 PyObject * obj1 = 0 ;
47950 char * kwnames[] = {
47951 (char *) "self",(char *) "item", NULL
47952 };
47953
47954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47956 if (!SWIG_IsOK(res1)) {
47957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47958 }
47959 arg1 = reinterpret_cast< wxSizer * >(argp1);
47960 arg2 = obj1;
47961 {
47962 PyThreadState* __tstate = wxPyBeginAllowThreads();
47963 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47964 wxPyEndAllowThreads(__tstate);
47965 if (PyErr_Occurred()) SWIG_fail;
47966 }
47967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47968 return resultobj;
47969 fail:
47970 return NULL;
47971 }
47972
47973
47974 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47975 PyObject *resultobj = 0;
47976 wxSizer *arg1 = (wxSizer *) 0 ;
47977 PyObject *arg2 = (PyObject *) 0 ;
47978 wxSize *arg3 = 0 ;
47979 void *argp1 = 0 ;
47980 int res1 = 0 ;
47981 wxSize temp3 ;
47982 PyObject * obj0 = 0 ;
47983 PyObject * obj1 = 0 ;
47984 PyObject * obj2 = 0 ;
47985 char * kwnames[] = {
47986 (char *) "self",(char *) "item",(char *) "size", NULL
47987 };
47988
47989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47991 if (!SWIG_IsOK(res1)) {
47992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47993 }
47994 arg1 = reinterpret_cast< wxSizer * >(argp1);
47995 arg2 = obj1;
47996 {
47997 arg3 = &temp3;
47998 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47999 }
48000 {
48001 PyThreadState* __tstate = wxPyBeginAllowThreads();
48002 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
48003 wxPyEndAllowThreads(__tstate);
48004 if (PyErr_Occurred()) SWIG_fail;
48005 }
48006 resultobj = SWIG_Py_Void();
48007 return resultobj;
48008 fail:
48009 return NULL;
48010 }
48011
48012
48013 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48014 PyObject *resultobj = 0;
48015 wxSizer *arg1 = (wxSizer *) 0 ;
48016 wxWindow *arg2 = (wxWindow *) 0 ;
48017 wxWindow *arg3 = (wxWindow *) 0 ;
48018 bool arg4 = (bool) false ;
48019 bool result;
48020 void *argp1 = 0 ;
48021 int res1 = 0 ;
48022 void *argp2 = 0 ;
48023 int res2 = 0 ;
48024 void *argp3 = 0 ;
48025 int res3 = 0 ;
48026 bool val4 ;
48027 int ecode4 = 0 ;
48028 PyObject * obj0 = 0 ;
48029 PyObject * obj1 = 0 ;
48030 PyObject * obj2 = 0 ;
48031 PyObject * obj3 = 0 ;
48032 char * kwnames[] = {
48033 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
48034 };
48035
48036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48038 if (!SWIG_IsOK(res1)) {
48039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
48040 }
48041 arg1 = reinterpret_cast< wxSizer * >(argp1);
48042 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48043 if (!SWIG_IsOK(res2)) {
48044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
48045 }
48046 arg2 = reinterpret_cast< wxWindow * >(argp2);
48047 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
48048 if (!SWIG_IsOK(res3)) {
48049 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
48050 }
48051 arg3 = reinterpret_cast< wxWindow * >(argp3);
48052 if (obj3) {
48053 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48054 if (!SWIG_IsOK(ecode4)) {
48055 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
48056 }
48057 arg4 = static_cast< bool >(val4);
48058 }
48059 {
48060 PyThreadState* __tstate = wxPyBeginAllowThreads();
48061 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48062 wxPyEndAllowThreads(__tstate);
48063 if (PyErr_Occurred()) SWIG_fail;
48064 }
48065 {
48066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48067 }
48068 return resultobj;
48069 fail:
48070 return NULL;
48071 }
48072
48073
48074 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48075 PyObject *resultobj = 0;
48076 wxSizer *arg1 = (wxSizer *) 0 ;
48077 wxSizer *arg2 = (wxSizer *) 0 ;
48078 wxSizer *arg3 = (wxSizer *) 0 ;
48079 bool arg4 = (bool) false ;
48080 bool result;
48081 void *argp1 = 0 ;
48082 int res1 = 0 ;
48083 void *argp2 = 0 ;
48084 int res2 = 0 ;
48085 void *argp3 = 0 ;
48086 int res3 = 0 ;
48087 bool val4 ;
48088 int ecode4 = 0 ;
48089 PyObject * obj0 = 0 ;
48090 PyObject * obj1 = 0 ;
48091 PyObject * obj2 = 0 ;
48092 PyObject * obj3 = 0 ;
48093 char * kwnames[] = {
48094 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
48095 };
48096
48097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48099 if (!SWIG_IsOK(res1)) {
48100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48101 }
48102 arg1 = reinterpret_cast< wxSizer * >(argp1);
48103 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
48104 if (!SWIG_IsOK(res2)) {
48105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
48106 }
48107 arg2 = reinterpret_cast< wxSizer * >(argp2);
48108 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
48109 if (!SWIG_IsOK(res3)) {
48110 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
48111 }
48112 arg3 = reinterpret_cast< wxSizer * >(argp3);
48113 if (obj3) {
48114 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48115 if (!SWIG_IsOK(ecode4)) {
48116 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
48117 }
48118 arg4 = static_cast< bool >(val4);
48119 }
48120 {
48121 PyThreadState* __tstate = wxPyBeginAllowThreads();
48122 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48123 wxPyEndAllowThreads(__tstate);
48124 if (PyErr_Occurred()) SWIG_fail;
48125 }
48126 {
48127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48128 }
48129 return resultobj;
48130 fail:
48131 return NULL;
48132 }
48133
48134
48135 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48136 PyObject *resultobj = 0;
48137 wxSizer *arg1 = (wxSizer *) 0 ;
48138 size_t arg2 ;
48139 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48140 bool result;
48141 void *argp1 = 0 ;
48142 int res1 = 0 ;
48143 size_t val2 ;
48144 int ecode2 = 0 ;
48145 void *argp3 = 0 ;
48146 int res3 = 0 ;
48147 PyObject * obj0 = 0 ;
48148 PyObject * obj1 = 0 ;
48149 PyObject * obj2 = 0 ;
48150 char * kwnames[] = {
48151 (char *) "self",(char *) "index",(char *) "newitem", NULL
48152 };
48153
48154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48156 if (!SWIG_IsOK(res1)) {
48157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48158 }
48159 arg1 = reinterpret_cast< wxSizer * >(argp1);
48160 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48161 if (!SWIG_IsOK(ecode2)) {
48162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
48163 }
48164 arg2 = static_cast< size_t >(val2);
48165 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48166 if (!SWIG_IsOK(res3)) {
48167 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48168 }
48169 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
48170 {
48171 PyThreadState* __tstate = wxPyBeginAllowThreads();
48172 result = (bool)(arg1)->Replace(arg2,arg3);
48173 wxPyEndAllowThreads(__tstate);
48174 if (PyErr_Occurred()) SWIG_fail;
48175 }
48176 {
48177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48178 }
48179 return resultobj;
48180 fail:
48181 return NULL;
48182 }
48183
48184
48185 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48186 PyObject *resultobj = 0;
48187 wxSizer *arg1 = (wxSizer *) 0 ;
48188 wxWindow *arg2 = (wxWindow *) 0 ;
48189 void *argp1 = 0 ;
48190 int res1 = 0 ;
48191 void *argp2 = 0 ;
48192 int res2 = 0 ;
48193 PyObject * obj0 = 0 ;
48194 PyObject * obj1 = 0 ;
48195 char * kwnames[] = {
48196 (char *) "self",(char *) "window", NULL
48197 };
48198
48199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
48200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48201 if (!SWIG_IsOK(res1)) {
48202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
48203 }
48204 arg1 = reinterpret_cast< wxSizer * >(argp1);
48205 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48206 if (!SWIG_IsOK(res2)) {
48207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
48208 }
48209 arg2 = reinterpret_cast< wxWindow * >(argp2);
48210 {
48211 PyThreadState* __tstate = wxPyBeginAllowThreads();
48212 (arg1)->SetContainingWindow(arg2);
48213 wxPyEndAllowThreads(__tstate);
48214 if (PyErr_Occurred()) SWIG_fail;
48215 }
48216 resultobj = SWIG_Py_Void();
48217 return resultobj;
48218 fail:
48219 return NULL;
48220 }
48221
48222
48223 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48224 PyObject *resultobj = 0;
48225 wxSizer *arg1 = (wxSizer *) 0 ;
48226 wxWindow *result = 0 ;
48227 void *argp1 = 0 ;
48228 int res1 = 0 ;
48229 PyObject *swig_obj[1] ;
48230
48231 if (!args) SWIG_fail;
48232 swig_obj[0] = args;
48233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48234 if (!SWIG_IsOK(res1)) {
48235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
48236 }
48237 arg1 = reinterpret_cast< wxSizer * >(argp1);
48238 {
48239 PyThreadState* __tstate = wxPyBeginAllowThreads();
48240 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
48241 wxPyEndAllowThreads(__tstate);
48242 if (PyErr_Occurred()) SWIG_fail;
48243 }
48244 {
48245 resultobj = wxPyMake_wxObject(result, 0);
48246 }
48247 return resultobj;
48248 fail:
48249 return NULL;
48250 }
48251
48252
48253 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48254 PyObject *resultobj = 0;
48255 wxSizer *arg1 = (wxSizer *) 0 ;
48256 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48257 wxSizerItem *result = 0 ;
48258 void *argp1 = 0 ;
48259 int res1 = 0 ;
48260 int res2 = 0 ;
48261 PyObject * obj0 = 0 ;
48262 PyObject * obj1 = 0 ;
48263 char * kwnames[] = {
48264 (char *) "self",(char *) "item", NULL
48265 };
48266
48267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
48268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48269 if (!SWIG_IsOK(res1)) {
48270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48271 }
48272 arg1 = reinterpret_cast< wxSizer * >(argp1);
48273 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48274 if (!SWIG_IsOK(res2)) {
48275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48276 }
48277 {
48278 PyThreadState* __tstate = wxPyBeginAllowThreads();
48279 result = (wxSizerItem *)(arg1)->Add(arg2);
48280 wxPyEndAllowThreads(__tstate);
48281 if (PyErr_Occurred()) SWIG_fail;
48282 }
48283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48284 return resultobj;
48285 fail:
48286 return NULL;
48287 }
48288
48289
48290 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48291 PyObject *resultobj = 0;
48292 wxSizer *arg1 = (wxSizer *) 0 ;
48293 size_t arg2 ;
48294 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48295 wxSizerItem *result = 0 ;
48296 void *argp1 = 0 ;
48297 int res1 = 0 ;
48298 size_t val2 ;
48299 int ecode2 = 0 ;
48300 int res3 = 0 ;
48301 PyObject * obj0 = 0 ;
48302 PyObject * obj1 = 0 ;
48303 PyObject * obj2 = 0 ;
48304 char * kwnames[] = {
48305 (char *) "self",(char *) "index",(char *) "item", NULL
48306 };
48307
48308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48310 if (!SWIG_IsOK(res1)) {
48311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48312 }
48313 arg1 = reinterpret_cast< wxSizer * >(argp1);
48314 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48315 if (!SWIG_IsOK(ecode2)) {
48316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
48317 }
48318 arg2 = static_cast< size_t >(val2);
48319 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48320 if (!SWIG_IsOK(res3)) {
48321 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48322 }
48323 {
48324 PyThreadState* __tstate = wxPyBeginAllowThreads();
48325 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
48326 wxPyEndAllowThreads(__tstate);
48327 if (PyErr_Occurred()) SWIG_fail;
48328 }
48329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48330 return resultobj;
48331 fail:
48332 return NULL;
48333 }
48334
48335
48336 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48337 PyObject *resultobj = 0;
48338 wxSizer *arg1 = (wxSizer *) 0 ;
48339 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48340 wxSizerItem *result = 0 ;
48341 void *argp1 = 0 ;
48342 int res1 = 0 ;
48343 int res2 = 0 ;
48344 PyObject * obj0 = 0 ;
48345 PyObject * obj1 = 0 ;
48346 char * kwnames[] = {
48347 (char *) "self",(char *) "item", NULL
48348 };
48349
48350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
48351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48352 if (!SWIG_IsOK(res1)) {
48353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48354 }
48355 arg1 = reinterpret_cast< wxSizer * >(argp1);
48356 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48357 if (!SWIG_IsOK(res2)) {
48358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48359 }
48360 {
48361 PyThreadState* __tstate = wxPyBeginAllowThreads();
48362 result = (wxSizerItem *)(arg1)->Prepend(arg2);
48363 wxPyEndAllowThreads(__tstate);
48364 if (PyErr_Occurred()) SWIG_fail;
48365 }
48366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48367 return resultobj;
48368 fail:
48369 return NULL;
48370 }
48371
48372
48373 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48374 PyObject *resultobj = 0;
48375 wxSizer *arg1 = (wxSizer *) 0 ;
48376 int arg2 ;
48377 int arg3 ;
48378 int arg4 ;
48379 int arg5 ;
48380 void *argp1 = 0 ;
48381 int res1 = 0 ;
48382 int val2 ;
48383 int ecode2 = 0 ;
48384 int val3 ;
48385 int ecode3 = 0 ;
48386 int val4 ;
48387 int ecode4 = 0 ;
48388 int val5 ;
48389 int ecode5 = 0 ;
48390 PyObject * obj0 = 0 ;
48391 PyObject * obj1 = 0 ;
48392 PyObject * obj2 = 0 ;
48393 PyObject * obj3 = 0 ;
48394 PyObject * obj4 = 0 ;
48395 char * kwnames[] = {
48396 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
48397 };
48398
48399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48401 if (!SWIG_IsOK(res1)) {
48402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
48403 }
48404 arg1 = reinterpret_cast< wxSizer * >(argp1);
48405 ecode2 = SWIG_AsVal_int(obj1, &val2);
48406 if (!SWIG_IsOK(ecode2)) {
48407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
48408 }
48409 arg2 = static_cast< int >(val2);
48410 ecode3 = SWIG_AsVal_int(obj2, &val3);
48411 if (!SWIG_IsOK(ecode3)) {
48412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
48413 }
48414 arg3 = static_cast< int >(val3);
48415 ecode4 = SWIG_AsVal_int(obj3, &val4);
48416 if (!SWIG_IsOK(ecode4)) {
48417 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
48418 }
48419 arg4 = static_cast< int >(val4);
48420 ecode5 = SWIG_AsVal_int(obj4, &val5);
48421 if (!SWIG_IsOK(ecode5)) {
48422 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
48423 }
48424 arg5 = static_cast< int >(val5);
48425 {
48426 PyThreadState* __tstate = wxPyBeginAllowThreads();
48427 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
48428 wxPyEndAllowThreads(__tstate);
48429 if (PyErr_Occurred()) SWIG_fail;
48430 }
48431 resultobj = SWIG_Py_Void();
48432 return resultobj;
48433 fail:
48434 return NULL;
48435 }
48436
48437
48438 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48439 PyObject *resultobj = 0;
48440 wxSizer *arg1 = (wxSizer *) 0 ;
48441 wxSize *arg2 = 0 ;
48442 void *argp1 = 0 ;
48443 int res1 = 0 ;
48444 wxSize temp2 ;
48445 PyObject * obj0 = 0 ;
48446 PyObject * obj1 = 0 ;
48447 char * kwnames[] = {
48448 (char *) "self",(char *) "size", NULL
48449 };
48450
48451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
48452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48453 if (!SWIG_IsOK(res1)) {
48454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48455 }
48456 arg1 = reinterpret_cast< wxSizer * >(argp1);
48457 {
48458 arg2 = &temp2;
48459 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48460 }
48461 {
48462 PyThreadState* __tstate = wxPyBeginAllowThreads();
48463 (arg1)->SetMinSize((wxSize const &)*arg2);
48464 wxPyEndAllowThreads(__tstate);
48465 if (PyErr_Occurred()) SWIG_fail;
48466 }
48467 resultobj = SWIG_Py_Void();
48468 return resultobj;
48469 fail:
48470 return NULL;
48471 }
48472
48473
48474 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48475 PyObject *resultobj = 0;
48476 wxSizer *arg1 = (wxSizer *) 0 ;
48477 wxSize result;
48478 void *argp1 = 0 ;
48479 int res1 = 0 ;
48480 PyObject *swig_obj[1] ;
48481
48482 if (!args) SWIG_fail;
48483 swig_obj[0] = args;
48484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48485 if (!SWIG_IsOK(res1)) {
48486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48487 }
48488 arg1 = reinterpret_cast< wxSizer * >(argp1);
48489 {
48490 PyThreadState* __tstate = wxPyBeginAllowThreads();
48491 result = (arg1)->GetSize();
48492 wxPyEndAllowThreads(__tstate);
48493 if (PyErr_Occurred()) SWIG_fail;
48494 }
48495 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48496 return resultobj;
48497 fail:
48498 return NULL;
48499 }
48500
48501
48502 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48503 PyObject *resultobj = 0;
48504 wxSizer *arg1 = (wxSizer *) 0 ;
48505 wxPoint result;
48506 void *argp1 = 0 ;
48507 int res1 = 0 ;
48508 PyObject *swig_obj[1] ;
48509
48510 if (!args) SWIG_fail;
48511 swig_obj[0] = args;
48512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48513 if (!SWIG_IsOK(res1)) {
48514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
48515 }
48516 arg1 = reinterpret_cast< wxSizer * >(argp1);
48517 {
48518 PyThreadState* __tstate = wxPyBeginAllowThreads();
48519 result = (arg1)->GetPosition();
48520 wxPyEndAllowThreads(__tstate);
48521 if (PyErr_Occurred()) SWIG_fail;
48522 }
48523 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
48524 return resultobj;
48525 fail:
48526 return NULL;
48527 }
48528
48529
48530 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48531 PyObject *resultobj = 0;
48532 wxSizer *arg1 = (wxSizer *) 0 ;
48533 wxSize result;
48534 void *argp1 = 0 ;
48535 int res1 = 0 ;
48536 PyObject *swig_obj[1] ;
48537
48538 if (!args) SWIG_fail;
48539 swig_obj[0] = args;
48540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48541 if (!SWIG_IsOK(res1)) {
48542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48543 }
48544 arg1 = reinterpret_cast< wxSizer * >(argp1);
48545 {
48546 PyThreadState* __tstate = wxPyBeginAllowThreads();
48547 result = (arg1)->GetMinSize();
48548 wxPyEndAllowThreads(__tstate);
48549 if (PyErr_Occurred()) SWIG_fail;
48550 }
48551 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48552 return resultobj;
48553 fail:
48554 return NULL;
48555 }
48556
48557
48558 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48559 PyObject *resultobj = 0;
48560 wxSizer *arg1 = (wxSizer *) 0 ;
48561 void *argp1 = 0 ;
48562 int res1 = 0 ;
48563 PyObject *swig_obj[1] ;
48564
48565 if (!args) SWIG_fail;
48566 swig_obj[0] = args;
48567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48568 if (!SWIG_IsOK(res1)) {
48569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48570 }
48571 arg1 = reinterpret_cast< wxSizer * >(argp1);
48572 {
48573 PyThreadState* __tstate = wxPyBeginAllowThreads();
48574 (arg1)->RecalcSizes();
48575 wxPyEndAllowThreads(__tstate);
48576 if (PyErr_Occurred()) SWIG_fail;
48577 }
48578 resultobj = SWIG_Py_Void();
48579 return resultobj;
48580 fail:
48581 return NULL;
48582 }
48583
48584
48585 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48586 PyObject *resultobj = 0;
48587 wxSizer *arg1 = (wxSizer *) 0 ;
48588 wxSize result;
48589 void *argp1 = 0 ;
48590 int res1 = 0 ;
48591 PyObject *swig_obj[1] ;
48592
48593 if (!args) SWIG_fail;
48594 swig_obj[0] = args;
48595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48596 if (!SWIG_IsOK(res1)) {
48597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48598 }
48599 arg1 = reinterpret_cast< wxSizer * >(argp1);
48600 {
48601 PyThreadState* __tstate = wxPyBeginAllowThreads();
48602 result = (arg1)->CalcMin();
48603 wxPyEndAllowThreads(__tstate);
48604 if (PyErr_Occurred()) SWIG_fail;
48605 }
48606 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48607 return resultobj;
48608 fail:
48609 return NULL;
48610 }
48611
48612
48613 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48614 PyObject *resultobj = 0;
48615 wxSizer *arg1 = (wxSizer *) 0 ;
48616 void *argp1 = 0 ;
48617 int res1 = 0 ;
48618 PyObject *swig_obj[1] ;
48619
48620 if (!args) SWIG_fail;
48621 swig_obj[0] = args;
48622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48623 if (!SWIG_IsOK(res1)) {
48624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48625 }
48626 arg1 = reinterpret_cast< wxSizer * >(argp1);
48627 {
48628 PyThreadState* __tstate = wxPyBeginAllowThreads();
48629 (arg1)->Layout();
48630 wxPyEndAllowThreads(__tstate);
48631 if (PyErr_Occurred()) SWIG_fail;
48632 }
48633 resultobj = SWIG_Py_Void();
48634 return resultobj;
48635 fail:
48636 return NULL;
48637 }
48638
48639
48640 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48641 PyObject *resultobj = 0;
48642 wxSizer *arg1 = (wxSizer *) 0 ;
48643 wxWindow *arg2 = (wxWindow *) 0 ;
48644 wxSize result;
48645 void *argp1 = 0 ;
48646 int res1 = 0 ;
48647 void *argp2 = 0 ;
48648 int res2 = 0 ;
48649 PyObject * obj0 = 0 ;
48650 PyObject * obj1 = 0 ;
48651 char * kwnames[] = {
48652 (char *) "self",(char *) "window", NULL
48653 };
48654
48655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48657 if (!SWIG_IsOK(res1)) {
48658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48659 }
48660 arg1 = reinterpret_cast< wxSizer * >(argp1);
48661 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48662 if (!SWIG_IsOK(res2)) {
48663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48664 }
48665 arg2 = reinterpret_cast< wxWindow * >(argp2);
48666 {
48667 PyThreadState* __tstate = wxPyBeginAllowThreads();
48668 result = (arg1)->Fit(arg2);
48669 wxPyEndAllowThreads(__tstate);
48670 if (PyErr_Occurred()) SWIG_fail;
48671 }
48672 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48673 return resultobj;
48674 fail:
48675 return NULL;
48676 }
48677
48678
48679 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48680 PyObject *resultobj = 0;
48681 wxSizer *arg1 = (wxSizer *) 0 ;
48682 wxWindow *arg2 = (wxWindow *) 0 ;
48683 void *argp1 = 0 ;
48684 int res1 = 0 ;
48685 void *argp2 = 0 ;
48686 int res2 = 0 ;
48687 PyObject * obj0 = 0 ;
48688 PyObject * obj1 = 0 ;
48689 char * kwnames[] = {
48690 (char *) "self",(char *) "window", NULL
48691 };
48692
48693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48695 if (!SWIG_IsOK(res1)) {
48696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48697 }
48698 arg1 = reinterpret_cast< wxSizer * >(argp1);
48699 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48700 if (!SWIG_IsOK(res2)) {
48701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48702 }
48703 arg2 = reinterpret_cast< wxWindow * >(argp2);
48704 {
48705 PyThreadState* __tstate = wxPyBeginAllowThreads();
48706 (arg1)->FitInside(arg2);
48707 wxPyEndAllowThreads(__tstate);
48708 if (PyErr_Occurred()) SWIG_fail;
48709 }
48710 resultobj = SWIG_Py_Void();
48711 return resultobj;
48712 fail:
48713 return NULL;
48714 }
48715
48716
48717 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48718 PyObject *resultobj = 0;
48719 wxSizer *arg1 = (wxSizer *) 0 ;
48720 wxWindow *arg2 = (wxWindow *) 0 ;
48721 void *argp1 = 0 ;
48722 int res1 = 0 ;
48723 void *argp2 = 0 ;
48724 int res2 = 0 ;
48725 PyObject * obj0 = 0 ;
48726 PyObject * obj1 = 0 ;
48727 char * kwnames[] = {
48728 (char *) "self",(char *) "window", NULL
48729 };
48730
48731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48733 if (!SWIG_IsOK(res1)) {
48734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48735 }
48736 arg1 = reinterpret_cast< wxSizer * >(argp1);
48737 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48738 if (!SWIG_IsOK(res2)) {
48739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48740 }
48741 arg2 = reinterpret_cast< wxWindow * >(argp2);
48742 {
48743 PyThreadState* __tstate = wxPyBeginAllowThreads();
48744 (arg1)->SetSizeHints(arg2);
48745 wxPyEndAllowThreads(__tstate);
48746 if (PyErr_Occurred()) SWIG_fail;
48747 }
48748 resultobj = SWIG_Py_Void();
48749 return resultobj;
48750 fail:
48751 return NULL;
48752 }
48753
48754
48755 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48756 PyObject *resultobj = 0;
48757 wxSizer *arg1 = (wxSizer *) 0 ;
48758 wxWindow *arg2 = (wxWindow *) 0 ;
48759 void *argp1 = 0 ;
48760 int res1 = 0 ;
48761 void *argp2 = 0 ;
48762 int res2 = 0 ;
48763 PyObject * obj0 = 0 ;
48764 PyObject * obj1 = 0 ;
48765 char * kwnames[] = {
48766 (char *) "self",(char *) "window", NULL
48767 };
48768
48769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48771 if (!SWIG_IsOK(res1)) {
48772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48773 }
48774 arg1 = reinterpret_cast< wxSizer * >(argp1);
48775 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48776 if (!SWIG_IsOK(res2)) {
48777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48778 }
48779 arg2 = reinterpret_cast< wxWindow * >(argp2);
48780 {
48781 PyThreadState* __tstate = wxPyBeginAllowThreads();
48782 (arg1)->SetVirtualSizeHints(arg2);
48783 wxPyEndAllowThreads(__tstate);
48784 if (PyErr_Occurred()) SWIG_fail;
48785 }
48786 resultobj = SWIG_Py_Void();
48787 return resultobj;
48788 fail:
48789 return NULL;
48790 }
48791
48792
48793 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48794 PyObject *resultobj = 0;
48795 wxSizer *arg1 = (wxSizer *) 0 ;
48796 bool arg2 = (bool) false ;
48797 void *argp1 = 0 ;
48798 int res1 = 0 ;
48799 bool val2 ;
48800 int ecode2 = 0 ;
48801 PyObject * obj0 = 0 ;
48802 PyObject * obj1 = 0 ;
48803 char * kwnames[] = {
48804 (char *) "self",(char *) "deleteWindows", NULL
48805 };
48806
48807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48809 if (!SWIG_IsOK(res1)) {
48810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48811 }
48812 arg1 = reinterpret_cast< wxSizer * >(argp1);
48813 if (obj1) {
48814 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48815 if (!SWIG_IsOK(ecode2)) {
48816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48817 }
48818 arg2 = static_cast< bool >(val2);
48819 }
48820 {
48821 PyThreadState* __tstate = wxPyBeginAllowThreads();
48822 (arg1)->Clear(arg2);
48823 wxPyEndAllowThreads(__tstate);
48824 if (PyErr_Occurred()) SWIG_fail;
48825 }
48826 resultobj = SWIG_Py_Void();
48827 return resultobj;
48828 fail:
48829 return NULL;
48830 }
48831
48832
48833 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48834 PyObject *resultobj = 0;
48835 wxSizer *arg1 = (wxSizer *) 0 ;
48836 void *argp1 = 0 ;
48837 int res1 = 0 ;
48838 PyObject *swig_obj[1] ;
48839
48840 if (!args) SWIG_fail;
48841 swig_obj[0] = args;
48842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48843 if (!SWIG_IsOK(res1)) {
48844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48845 }
48846 arg1 = reinterpret_cast< wxSizer * >(argp1);
48847 {
48848 PyThreadState* __tstate = wxPyBeginAllowThreads();
48849 (arg1)->DeleteWindows();
48850 wxPyEndAllowThreads(__tstate);
48851 if (PyErr_Occurred()) SWIG_fail;
48852 }
48853 resultobj = SWIG_Py_Void();
48854 return resultobj;
48855 fail:
48856 return NULL;
48857 }
48858
48859
48860 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48861 PyObject *resultobj = 0;
48862 wxSizer *arg1 = (wxSizer *) 0 ;
48863 PyObject *result = 0 ;
48864 void *argp1 = 0 ;
48865 int res1 = 0 ;
48866 PyObject *swig_obj[1] ;
48867
48868 if (!args) SWIG_fail;
48869 swig_obj[0] = args;
48870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48871 if (!SWIG_IsOK(res1)) {
48872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48873 }
48874 arg1 = reinterpret_cast< wxSizer * >(argp1);
48875 {
48876 PyThreadState* __tstate = wxPyBeginAllowThreads();
48877 result = (PyObject *)wxSizer_GetChildren(arg1);
48878 wxPyEndAllowThreads(__tstate);
48879 if (PyErr_Occurred()) SWIG_fail;
48880 }
48881 resultobj = result;
48882 return resultobj;
48883 fail:
48884 return NULL;
48885 }
48886
48887
48888 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48889 PyObject *resultobj = 0;
48890 wxSizer *arg1 = (wxSizer *) 0 ;
48891 PyObject *arg2 = (PyObject *) 0 ;
48892 bool arg3 = (bool) true ;
48893 bool arg4 = (bool) false ;
48894 bool result;
48895 void *argp1 = 0 ;
48896 int res1 = 0 ;
48897 bool val3 ;
48898 int ecode3 = 0 ;
48899 bool val4 ;
48900 int ecode4 = 0 ;
48901 PyObject * obj0 = 0 ;
48902 PyObject * obj1 = 0 ;
48903 PyObject * obj2 = 0 ;
48904 PyObject * obj3 = 0 ;
48905 char * kwnames[] = {
48906 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48907 };
48908
48909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48911 if (!SWIG_IsOK(res1)) {
48912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48913 }
48914 arg1 = reinterpret_cast< wxSizer * >(argp1);
48915 arg2 = obj1;
48916 if (obj2) {
48917 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48918 if (!SWIG_IsOK(ecode3)) {
48919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48920 }
48921 arg3 = static_cast< bool >(val3);
48922 }
48923 if (obj3) {
48924 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48925 if (!SWIG_IsOK(ecode4)) {
48926 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48927 }
48928 arg4 = static_cast< bool >(val4);
48929 }
48930 {
48931 PyThreadState* __tstate = wxPyBeginAllowThreads();
48932 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48933 wxPyEndAllowThreads(__tstate);
48934 if (PyErr_Occurred()) SWIG_fail;
48935 }
48936 {
48937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48938 }
48939 return resultobj;
48940 fail:
48941 return NULL;
48942 }
48943
48944
48945 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48946 PyObject *resultobj = 0;
48947 wxSizer *arg1 = (wxSizer *) 0 ;
48948 PyObject *arg2 = (PyObject *) 0 ;
48949 bool result;
48950 void *argp1 = 0 ;
48951 int res1 = 0 ;
48952 PyObject * obj0 = 0 ;
48953 PyObject * obj1 = 0 ;
48954 char * kwnames[] = {
48955 (char *) "self",(char *) "item", NULL
48956 };
48957
48958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48960 if (!SWIG_IsOK(res1)) {
48961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48962 }
48963 arg1 = reinterpret_cast< wxSizer * >(argp1);
48964 arg2 = obj1;
48965 {
48966 PyThreadState* __tstate = wxPyBeginAllowThreads();
48967 result = (bool)wxSizer_IsShown(arg1,arg2);
48968 wxPyEndAllowThreads(__tstate);
48969 if (PyErr_Occurred()) SWIG_fail;
48970 }
48971 {
48972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48973 }
48974 return resultobj;
48975 fail:
48976 return NULL;
48977 }
48978
48979
48980 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48981 PyObject *resultobj = 0;
48982 wxSizer *arg1 = (wxSizer *) 0 ;
48983 bool arg2 ;
48984 void *argp1 = 0 ;
48985 int res1 = 0 ;
48986 bool val2 ;
48987 int ecode2 = 0 ;
48988 PyObject * obj0 = 0 ;
48989 PyObject * obj1 = 0 ;
48990 char * kwnames[] = {
48991 (char *) "self",(char *) "show", NULL
48992 };
48993
48994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48996 if (!SWIG_IsOK(res1)) {
48997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48998 }
48999 arg1 = reinterpret_cast< wxSizer * >(argp1);
49000 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49001 if (!SWIG_IsOK(ecode2)) {
49002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
49003 }
49004 arg2 = static_cast< bool >(val2);
49005 {
49006 PyThreadState* __tstate = wxPyBeginAllowThreads();
49007 (arg1)->ShowItems(arg2);
49008 wxPyEndAllowThreads(__tstate);
49009 if (PyErr_Occurred()) SWIG_fail;
49010 }
49011 resultobj = SWIG_Py_Void();
49012 return resultobj;
49013 fail:
49014 return NULL;
49015 }
49016
49017
49018 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49019 PyObject *obj;
49020 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49021 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
49022 return SWIG_Py_Void();
49023 }
49024
49025 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49026 PyObject *resultobj = 0;
49027 wxPySizer *result = 0 ;
49028
49029 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
49030 {
49031 PyThreadState* __tstate = wxPyBeginAllowThreads();
49032 result = (wxPySizer *)new wxPySizer();
49033 wxPyEndAllowThreads(__tstate);
49034 if (PyErr_Occurred()) SWIG_fail;
49035 }
49036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
49037 return resultobj;
49038 fail:
49039 return NULL;
49040 }
49041
49042
49043 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49044 PyObject *resultobj = 0;
49045 wxPySizer *arg1 = (wxPySizer *) 0 ;
49046 PyObject *arg2 = (PyObject *) 0 ;
49047 PyObject *arg3 = (PyObject *) 0 ;
49048 void *argp1 = 0 ;
49049 int res1 = 0 ;
49050 PyObject * obj0 = 0 ;
49051 PyObject * obj1 = 0 ;
49052 PyObject * obj2 = 0 ;
49053 char * kwnames[] = {
49054 (char *) "self",(char *) "self",(char *) "_class", NULL
49055 };
49056
49057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
49059 if (!SWIG_IsOK(res1)) {
49060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
49061 }
49062 arg1 = reinterpret_cast< wxPySizer * >(argp1);
49063 arg2 = obj1;
49064 arg3 = obj2;
49065 {
49066 PyThreadState* __tstate = wxPyBeginAllowThreads();
49067 (arg1)->_setCallbackInfo(arg2,arg3);
49068 wxPyEndAllowThreads(__tstate);
49069 if (PyErr_Occurred()) SWIG_fail;
49070 }
49071 resultobj = SWIG_Py_Void();
49072 return resultobj;
49073 fail:
49074 return NULL;
49075 }
49076
49077
49078 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49079 PyObject *obj;
49080 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49081 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
49082 return SWIG_Py_Void();
49083 }
49084
49085 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49086 return SWIG_Python_InitShadowInstance(args);
49087 }
49088
49089 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49090 PyObject *resultobj = 0;
49091 int arg1 = (int) wxHORIZONTAL ;
49092 wxBoxSizer *result = 0 ;
49093 int val1 ;
49094 int ecode1 = 0 ;
49095 PyObject * obj0 = 0 ;
49096 char * kwnames[] = {
49097 (char *) "orient", NULL
49098 };
49099
49100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
49101 if (obj0) {
49102 ecode1 = SWIG_AsVal_int(obj0, &val1);
49103 if (!SWIG_IsOK(ecode1)) {
49104 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
49105 }
49106 arg1 = static_cast< int >(val1);
49107 }
49108 {
49109 PyThreadState* __tstate = wxPyBeginAllowThreads();
49110 result = (wxBoxSizer *)new wxBoxSizer(arg1);
49111 wxPyEndAllowThreads(__tstate);
49112 if (PyErr_Occurred()) SWIG_fail;
49113 }
49114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
49115 return resultobj;
49116 fail:
49117 return NULL;
49118 }
49119
49120
49121 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49122 PyObject *resultobj = 0;
49123 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49124 int result;
49125 void *argp1 = 0 ;
49126 int res1 = 0 ;
49127 PyObject *swig_obj[1] ;
49128
49129 if (!args) SWIG_fail;
49130 swig_obj[0] = args;
49131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49132 if (!SWIG_IsOK(res1)) {
49133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49134 }
49135 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49136 {
49137 PyThreadState* __tstate = wxPyBeginAllowThreads();
49138 result = (int)(arg1)->GetOrientation();
49139 wxPyEndAllowThreads(__tstate);
49140 if (PyErr_Occurred()) SWIG_fail;
49141 }
49142 resultobj = SWIG_From_int(static_cast< int >(result));
49143 return resultobj;
49144 fail:
49145 return NULL;
49146 }
49147
49148
49149 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49150 PyObject *resultobj = 0;
49151 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49152 int arg2 ;
49153 void *argp1 = 0 ;
49154 int res1 = 0 ;
49155 int val2 ;
49156 int ecode2 = 0 ;
49157 PyObject * obj0 = 0 ;
49158 PyObject * obj1 = 0 ;
49159 char * kwnames[] = {
49160 (char *) "self",(char *) "orient", NULL
49161 };
49162
49163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
49164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49165 if (!SWIG_IsOK(res1)) {
49166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49167 }
49168 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49169 ecode2 = SWIG_AsVal_int(obj1, &val2);
49170 if (!SWIG_IsOK(ecode2)) {
49171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
49172 }
49173 arg2 = static_cast< int >(val2);
49174 {
49175 PyThreadState* __tstate = wxPyBeginAllowThreads();
49176 (arg1)->SetOrientation(arg2);
49177 wxPyEndAllowThreads(__tstate);
49178 if (PyErr_Occurred()) SWIG_fail;
49179 }
49180 resultobj = SWIG_Py_Void();
49181 return resultobj;
49182 fail:
49183 return NULL;
49184 }
49185
49186
49187 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49188 PyObject *obj;
49189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49190 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
49191 return SWIG_Py_Void();
49192 }
49193
49194 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49195 return SWIG_Python_InitShadowInstance(args);
49196 }
49197
49198 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49199 PyObject *resultobj = 0;
49200 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
49201 int arg2 = (int) wxHORIZONTAL ;
49202 wxStaticBoxSizer *result = 0 ;
49203 void *argp1 = 0 ;
49204 int res1 = 0 ;
49205 int val2 ;
49206 int ecode2 = 0 ;
49207 PyObject * obj0 = 0 ;
49208 PyObject * obj1 = 0 ;
49209 char * kwnames[] = {
49210 (char *) "box",(char *) "orient", NULL
49211 };
49212
49213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
49215 if (!SWIG_IsOK(res1)) {
49216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
49217 }
49218 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
49219 if (obj1) {
49220 ecode2 = SWIG_AsVal_int(obj1, &val2);
49221 if (!SWIG_IsOK(ecode2)) {
49222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
49223 }
49224 arg2 = static_cast< int >(val2);
49225 }
49226 {
49227 PyThreadState* __tstate = wxPyBeginAllowThreads();
49228 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
49229 wxPyEndAllowThreads(__tstate);
49230 if (PyErr_Occurred()) SWIG_fail;
49231 }
49232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
49233 return resultobj;
49234 fail:
49235 return NULL;
49236 }
49237
49238
49239 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49240 PyObject *resultobj = 0;
49241 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
49242 wxStaticBox *result = 0 ;
49243 void *argp1 = 0 ;
49244 int res1 = 0 ;
49245 PyObject *swig_obj[1] ;
49246
49247 if (!args) SWIG_fail;
49248 swig_obj[0] = args;
49249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
49250 if (!SWIG_IsOK(res1)) {
49251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
49252 }
49253 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
49254 {
49255 PyThreadState* __tstate = wxPyBeginAllowThreads();
49256 result = (wxStaticBox *)(arg1)->GetStaticBox();
49257 wxPyEndAllowThreads(__tstate);
49258 if (PyErr_Occurred()) SWIG_fail;
49259 }
49260 {
49261 resultobj = wxPyMake_wxObject(result, (bool)0);
49262 }
49263 return resultobj;
49264 fail:
49265 return NULL;
49266 }
49267
49268
49269 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49270 PyObject *obj;
49271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49272 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
49273 return SWIG_Py_Void();
49274 }
49275
49276 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49277 return SWIG_Python_InitShadowInstance(args);
49278 }
49279
49280 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49281 PyObject *resultobj = 0;
49282 int arg1 = (int) 1 ;
49283 int arg2 = (int) 0 ;
49284 int arg3 = (int) 0 ;
49285 int arg4 = (int) 0 ;
49286 wxGridSizer *result = 0 ;
49287 int val1 ;
49288 int ecode1 = 0 ;
49289 int val2 ;
49290 int ecode2 = 0 ;
49291 int val3 ;
49292 int ecode3 = 0 ;
49293 int val4 ;
49294 int ecode4 = 0 ;
49295 PyObject * obj0 = 0 ;
49296 PyObject * obj1 = 0 ;
49297 PyObject * obj2 = 0 ;
49298 PyObject * obj3 = 0 ;
49299 char * kwnames[] = {
49300 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49301 };
49302
49303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49304 if (obj0) {
49305 ecode1 = SWIG_AsVal_int(obj0, &val1);
49306 if (!SWIG_IsOK(ecode1)) {
49307 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
49308 }
49309 arg1 = static_cast< int >(val1);
49310 }
49311 if (obj1) {
49312 ecode2 = SWIG_AsVal_int(obj1, &val2);
49313 if (!SWIG_IsOK(ecode2)) {
49314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
49315 }
49316 arg2 = static_cast< int >(val2);
49317 }
49318 if (obj2) {
49319 ecode3 = SWIG_AsVal_int(obj2, &val3);
49320 if (!SWIG_IsOK(ecode3)) {
49321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
49322 }
49323 arg3 = static_cast< int >(val3);
49324 }
49325 if (obj3) {
49326 ecode4 = SWIG_AsVal_int(obj3, &val4);
49327 if (!SWIG_IsOK(ecode4)) {
49328 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
49329 }
49330 arg4 = static_cast< int >(val4);
49331 }
49332 {
49333 PyThreadState* __tstate = wxPyBeginAllowThreads();
49334 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
49335 wxPyEndAllowThreads(__tstate);
49336 if (PyErr_Occurred()) SWIG_fail;
49337 }
49338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
49339 return resultobj;
49340 fail:
49341 return NULL;
49342 }
49343
49344
49345 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49346 PyObject *resultobj = 0;
49347 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49348 int arg2 ;
49349 void *argp1 = 0 ;
49350 int res1 = 0 ;
49351 int val2 ;
49352 int ecode2 = 0 ;
49353 PyObject * obj0 = 0 ;
49354 PyObject * obj1 = 0 ;
49355 char * kwnames[] = {
49356 (char *) "self",(char *) "cols", NULL
49357 };
49358
49359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
49360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49361 if (!SWIG_IsOK(res1)) {
49362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49363 }
49364 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49365 ecode2 = SWIG_AsVal_int(obj1, &val2);
49366 if (!SWIG_IsOK(ecode2)) {
49367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
49368 }
49369 arg2 = static_cast< int >(val2);
49370 {
49371 PyThreadState* __tstate = wxPyBeginAllowThreads();
49372 (arg1)->SetCols(arg2);
49373 wxPyEndAllowThreads(__tstate);
49374 if (PyErr_Occurred()) SWIG_fail;
49375 }
49376 resultobj = SWIG_Py_Void();
49377 return resultobj;
49378 fail:
49379 return NULL;
49380 }
49381
49382
49383 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49384 PyObject *resultobj = 0;
49385 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49386 int arg2 ;
49387 void *argp1 = 0 ;
49388 int res1 = 0 ;
49389 int val2 ;
49390 int ecode2 = 0 ;
49391 PyObject * obj0 = 0 ;
49392 PyObject * obj1 = 0 ;
49393 char * kwnames[] = {
49394 (char *) "self",(char *) "rows", NULL
49395 };
49396
49397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
49398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49399 if (!SWIG_IsOK(res1)) {
49400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49401 }
49402 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49403 ecode2 = SWIG_AsVal_int(obj1, &val2);
49404 if (!SWIG_IsOK(ecode2)) {
49405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
49406 }
49407 arg2 = static_cast< int >(val2);
49408 {
49409 PyThreadState* __tstate = wxPyBeginAllowThreads();
49410 (arg1)->SetRows(arg2);
49411 wxPyEndAllowThreads(__tstate);
49412 if (PyErr_Occurred()) SWIG_fail;
49413 }
49414 resultobj = SWIG_Py_Void();
49415 return resultobj;
49416 fail:
49417 return NULL;
49418 }
49419
49420
49421 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49422 PyObject *resultobj = 0;
49423 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49424 int arg2 ;
49425 void *argp1 = 0 ;
49426 int res1 = 0 ;
49427 int val2 ;
49428 int ecode2 = 0 ;
49429 PyObject * obj0 = 0 ;
49430 PyObject * obj1 = 0 ;
49431 char * kwnames[] = {
49432 (char *) "self",(char *) "gap", NULL
49433 };
49434
49435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
49436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49437 if (!SWIG_IsOK(res1)) {
49438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49439 }
49440 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49441 ecode2 = SWIG_AsVal_int(obj1, &val2);
49442 if (!SWIG_IsOK(ecode2)) {
49443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
49444 }
49445 arg2 = static_cast< int >(val2);
49446 {
49447 PyThreadState* __tstate = wxPyBeginAllowThreads();
49448 (arg1)->SetVGap(arg2);
49449 wxPyEndAllowThreads(__tstate);
49450 if (PyErr_Occurred()) SWIG_fail;
49451 }
49452 resultobj = SWIG_Py_Void();
49453 return resultobj;
49454 fail:
49455 return NULL;
49456 }
49457
49458
49459 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49460 PyObject *resultobj = 0;
49461 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49462 int arg2 ;
49463 void *argp1 = 0 ;
49464 int res1 = 0 ;
49465 int val2 ;
49466 int ecode2 = 0 ;
49467 PyObject * obj0 = 0 ;
49468 PyObject * obj1 = 0 ;
49469 char * kwnames[] = {
49470 (char *) "self",(char *) "gap", NULL
49471 };
49472
49473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
49474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49475 if (!SWIG_IsOK(res1)) {
49476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49477 }
49478 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49479 ecode2 = SWIG_AsVal_int(obj1, &val2);
49480 if (!SWIG_IsOK(ecode2)) {
49481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
49482 }
49483 arg2 = static_cast< int >(val2);
49484 {
49485 PyThreadState* __tstate = wxPyBeginAllowThreads();
49486 (arg1)->SetHGap(arg2);
49487 wxPyEndAllowThreads(__tstate);
49488 if (PyErr_Occurred()) SWIG_fail;
49489 }
49490 resultobj = SWIG_Py_Void();
49491 return resultobj;
49492 fail:
49493 return NULL;
49494 }
49495
49496
49497 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49498 PyObject *resultobj = 0;
49499 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49500 int result;
49501 void *argp1 = 0 ;
49502 int res1 = 0 ;
49503 PyObject *swig_obj[1] ;
49504
49505 if (!args) SWIG_fail;
49506 swig_obj[0] = args;
49507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49508 if (!SWIG_IsOK(res1)) {
49509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49510 }
49511 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49512 {
49513 PyThreadState* __tstate = wxPyBeginAllowThreads();
49514 result = (int)(arg1)->GetCols();
49515 wxPyEndAllowThreads(__tstate);
49516 if (PyErr_Occurred()) SWIG_fail;
49517 }
49518 resultobj = SWIG_From_int(static_cast< int >(result));
49519 return resultobj;
49520 fail:
49521 return NULL;
49522 }
49523
49524
49525 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49526 PyObject *resultobj = 0;
49527 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49528 int result;
49529 void *argp1 = 0 ;
49530 int res1 = 0 ;
49531 PyObject *swig_obj[1] ;
49532
49533 if (!args) SWIG_fail;
49534 swig_obj[0] = args;
49535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49536 if (!SWIG_IsOK(res1)) {
49537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49538 }
49539 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49540 {
49541 PyThreadState* __tstate = wxPyBeginAllowThreads();
49542 result = (int)(arg1)->GetRows();
49543 wxPyEndAllowThreads(__tstate);
49544 if (PyErr_Occurred()) SWIG_fail;
49545 }
49546 resultobj = SWIG_From_int(static_cast< int >(result));
49547 return resultobj;
49548 fail:
49549 return NULL;
49550 }
49551
49552
49553 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49554 PyObject *resultobj = 0;
49555 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49556 int result;
49557 void *argp1 = 0 ;
49558 int res1 = 0 ;
49559 PyObject *swig_obj[1] ;
49560
49561 if (!args) SWIG_fail;
49562 swig_obj[0] = args;
49563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49564 if (!SWIG_IsOK(res1)) {
49565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49566 }
49567 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49568 {
49569 PyThreadState* __tstate = wxPyBeginAllowThreads();
49570 result = (int)(arg1)->GetVGap();
49571 wxPyEndAllowThreads(__tstate);
49572 if (PyErr_Occurred()) SWIG_fail;
49573 }
49574 resultobj = SWIG_From_int(static_cast< int >(result));
49575 return resultobj;
49576 fail:
49577 return NULL;
49578 }
49579
49580
49581 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49582 PyObject *resultobj = 0;
49583 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49584 int result;
49585 void *argp1 = 0 ;
49586 int res1 = 0 ;
49587 PyObject *swig_obj[1] ;
49588
49589 if (!args) SWIG_fail;
49590 swig_obj[0] = args;
49591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49592 if (!SWIG_IsOK(res1)) {
49593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49594 }
49595 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49596 {
49597 PyThreadState* __tstate = wxPyBeginAllowThreads();
49598 result = (int)(arg1)->GetHGap();
49599 wxPyEndAllowThreads(__tstate);
49600 if (PyErr_Occurred()) SWIG_fail;
49601 }
49602 resultobj = SWIG_From_int(static_cast< int >(result));
49603 return resultobj;
49604 fail:
49605 return NULL;
49606 }
49607
49608
49609 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49610 PyObject *obj;
49611 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49612 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49613 return SWIG_Py_Void();
49614 }
49615
49616 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49617 return SWIG_Python_InitShadowInstance(args);
49618 }
49619
49620 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49621 PyObject *resultobj = 0;
49622 int arg1 = (int) 1 ;
49623 int arg2 = (int) 0 ;
49624 int arg3 = (int) 0 ;
49625 int arg4 = (int) 0 ;
49626 wxFlexGridSizer *result = 0 ;
49627 int val1 ;
49628 int ecode1 = 0 ;
49629 int val2 ;
49630 int ecode2 = 0 ;
49631 int val3 ;
49632 int ecode3 = 0 ;
49633 int val4 ;
49634 int ecode4 = 0 ;
49635 PyObject * obj0 = 0 ;
49636 PyObject * obj1 = 0 ;
49637 PyObject * obj2 = 0 ;
49638 PyObject * obj3 = 0 ;
49639 char * kwnames[] = {
49640 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49641 };
49642
49643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49644 if (obj0) {
49645 ecode1 = SWIG_AsVal_int(obj0, &val1);
49646 if (!SWIG_IsOK(ecode1)) {
49647 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49648 }
49649 arg1 = static_cast< int >(val1);
49650 }
49651 if (obj1) {
49652 ecode2 = SWIG_AsVal_int(obj1, &val2);
49653 if (!SWIG_IsOK(ecode2)) {
49654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49655 }
49656 arg2 = static_cast< int >(val2);
49657 }
49658 if (obj2) {
49659 ecode3 = SWIG_AsVal_int(obj2, &val3);
49660 if (!SWIG_IsOK(ecode3)) {
49661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49662 }
49663 arg3 = static_cast< int >(val3);
49664 }
49665 if (obj3) {
49666 ecode4 = SWIG_AsVal_int(obj3, &val4);
49667 if (!SWIG_IsOK(ecode4)) {
49668 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49669 }
49670 arg4 = static_cast< int >(val4);
49671 }
49672 {
49673 PyThreadState* __tstate = wxPyBeginAllowThreads();
49674 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49675 wxPyEndAllowThreads(__tstate);
49676 if (PyErr_Occurred()) SWIG_fail;
49677 }
49678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49679 return resultobj;
49680 fail:
49681 return NULL;
49682 }
49683
49684
49685 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49686 PyObject *resultobj = 0;
49687 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49688 size_t arg2 ;
49689 int arg3 = (int) 0 ;
49690 void *argp1 = 0 ;
49691 int res1 = 0 ;
49692 size_t val2 ;
49693 int ecode2 = 0 ;
49694 int val3 ;
49695 int ecode3 = 0 ;
49696 PyObject * obj0 = 0 ;
49697 PyObject * obj1 = 0 ;
49698 PyObject * obj2 = 0 ;
49699 char * kwnames[] = {
49700 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49701 };
49702
49703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49705 if (!SWIG_IsOK(res1)) {
49706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49707 }
49708 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49709 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49710 if (!SWIG_IsOK(ecode2)) {
49711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49712 }
49713 arg2 = static_cast< size_t >(val2);
49714 if (obj2) {
49715 ecode3 = SWIG_AsVal_int(obj2, &val3);
49716 if (!SWIG_IsOK(ecode3)) {
49717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49718 }
49719 arg3 = static_cast< int >(val3);
49720 }
49721 {
49722 PyThreadState* __tstate = wxPyBeginAllowThreads();
49723 (arg1)->AddGrowableRow(arg2,arg3);
49724 wxPyEndAllowThreads(__tstate);
49725 if (PyErr_Occurred()) SWIG_fail;
49726 }
49727 resultobj = SWIG_Py_Void();
49728 return resultobj;
49729 fail:
49730 return NULL;
49731 }
49732
49733
49734 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49735 PyObject *resultobj = 0;
49736 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49737 size_t arg2 ;
49738 void *argp1 = 0 ;
49739 int res1 = 0 ;
49740 size_t val2 ;
49741 int ecode2 = 0 ;
49742 PyObject * obj0 = 0 ;
49743 PyObject * obj1 = 0 ;
49744 char * kwnames[] = {
49745 (char *) "self",(char *) "idx", NULL
49746 };
49747
49748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49750 if (!SWIG_IsOK(res1)) {
49751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49752 }
49753 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49754 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49755 if (!SWIG_IsOK(ecode2)) {
49756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49757 }
49758 arg2 = static_cast< size_t >(val2);
49759 {
49760 PyThreadState* __tstate = wxPyBeginAllowThreads();
49761 (arg1)->RemoveGrowableRow(arg2);
49762 wxPyEndAllowThreads(__tstate);
49763 if (PyErr_Occurred()) SWIG_fail;
49764 }
49765 resultobj = SWIG_Py_Void();
49766 return resultobj;
49767 fail:
49768 return NULL;
49769 }
49770
49771
49772 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49773 PyObject *resultobj = 0;
49774 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49775 size_t arg2 ;
49776 int arg3 = (int) 0 ;
49777 void *argp1 = 0 ;
49778 int res1 = 0 ;
49779 size_t val2 ;
49780 int ecode2 = 0 ;
49781 int val3 ;
49782 int ecode3 = 0 ;
49783 PyObject * obj0 = 0 ;
49784 PyObject * obj1 = 0 ;
49785 PyObject * obj2 = 0 ;
49786 char * kwnames[] = {
49787 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49788 };
49789
49790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49792 if (!SWIG_IsOK(res1)) {
49793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49794 }
49795 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49796 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49797 if (!SWIG_IsOK(ecode2)) {
49798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49799 }
49800 arg2 = static_cast< size_t >(val2);
49801 if (obj2) {
49802 ecode3 = SWIG_AsVal_int(obj2, &val3);
49803 if (!SWIG_IsOK(ecode3)) {
49804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49805 }
49806 arg3 = static_cast< int >(val3);
49807 }
49808 {
49809 PyThreadState* __tstate = wxPyBeginAllowThreads();
49810 (arg1)->AddGrowableCol(arg2,arg3);
49811 wxPyEndAllowThreads(__tstate);
49812 if (PyErr_Occurred()) SWIG_fail;
49813 }
49814 resultobj = SWIG_Py_Void();
49815 return resultobj;
49816 fail:
49817 return NULL;
49818 }
49819
49820
49821 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49822 PyObject *resultobj = 0;
49823 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49824 size_t arg2 ;
49825 void *argp1 = 0 ;
49826 int res1 = 0 ;
49827 size_t val2 ;
49828 int ecode2 = 0 ;
49829 PyObject * obj0 = 0 ;
49830 PyObject * obj1 = 0 ;
49831 char * kwnames[] = {
49832 (char *) "self",(char *) "idx", NULL
49833 };
49834
49835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49837 if (!SWIG_IsOK(res1)) {
49838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49839 }
49840 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49841 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49842 if (!SWIG_IsOK(ecode2)) {
49843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49844 }
49845 arg2 = static_cast< size_t >(val2);
49846 {
49847 PyThreadState* __tstate = wxPyBeginAllowThreads();
49848 (arg1)->RemoveGrowableCol(arg2);
49849 wxPyEndAllowThreads(__tstate);
49850 if (PyErr_Occurred()) SWIG_fail;
49851 }
49852 resultobj = SWIG_Py_Void();
49853 return resultobj;
49854 fail:
49855 return NULL;
49856 }
49857
49858
49859 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49860 PyObject *resultobj = 0;
49861 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49862 int arg2 ;
49863 void *argp1 = 0 ;
49864 int res1 = 0 ;
49865 int val2 ;
49866 int ecode2 = 0 ;
49867 PyObject * obj0 = 0 ;
49868 PyObject * obj1 = 0 ;
49869 char * kwnames[] = {
49870 (char *) "self",(char *) "direction", NULL
49871 };
49872
49873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49875 if (!SWIG_IsOK(res1)) {
49876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49877 }
49878 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49879 ecode2 = SWIG_AsVal_int(obj1, &val2);
49880 if (!SWIG_IsOK(ecode2)) {
49881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49882 }
49883 arg2 = static_cast< int >(val2);
49884 {
49885 PyThreadState* __tstate = wxPyBeginAllowThreads();
49886 (arg1)->SetFlexibleDirection(arg2);
49887 wxPyEndAllowThreads(__tstate);
49888 if (PyErr_Occurred()) SWIG_fail;
49889 }
49890 resultobj = SWIG_Py_Void();
49891 return resultobj;
49892 fail:
49893 return NULL;
49894 }
49895
49896
49897 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49898 PyObject *resultobj = 0;
49899 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49900 int result;
49901 void *argp1 = 0 ;
49902 int res1 = 0 ;
49903 PyObject *swig_obj[1] ;
49904
49905 if (!args) SWIG_fail;
49906 swig_obj[0] = args;
49907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49908 if (!SWIG_IsOK(res1)) {
49909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49910 }
49911 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49912 {
49913 PyThreadState* __tstate = wxPyBeginAllowThreads();
49914 result = (int)(arg1)->GetFlexibleDirection();
49915 wxPyEndAllowThreads(__tstate);
49916 if (PyErr_Occurred()) SWIG_fail;
49917 }
49918 resultobj = SWIG_From_int(static_cast< int >(result));
49919 return resultobj;
49920 fail:
49921 return NULL;
49922 }
49923
49924
49925 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49926 PyObject *resultobj = 0;
49927 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49928 wxFlexSizerGrowMode arg2 ;
49929 void *argp1 = 0 ;
49930 int res1 = 0 ;
49931 int val2 ;
49932 int ecode2 = 0 ;
49933 PyObject * obj0 = 0 ;
49934 PyObject * obj1 = 0 ;
49935 char * kwnames[] = {
49936 (char *) "self",(char *) "mode", NULL
49937 };
49938
49939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49941 if (!SWIG_IsOK(res1)) {
49942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49943 }
49944 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49945 ecode2 = SWIG_AsVal_int(obj1, &val2);
49946 if (!SWIG_IsOK(ecode2)) {
49947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49948 }
49949 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49950 {
49951 PyThreadState* __tstate = wxPyBeginAllowThreads();
49952 (arg1)->SetNonFlexibleGrowMode(arg2);
49953 wxPyEndAllowThreads(__tstate);
49954 if (PyErr_Occurred()) SWIG_fail;
49955 }
49956 resultobj = SWIG_Py_Void();
49957 return resultobj;
49958 fail:
49959 return NULL;
49960 }
49961
49962
49963 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49964 PyObject *resultobj = 0;
49965 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49966 wxFlexSizerGrowMode result;
49967 void *argp1 = 0 ;
49968 int res1 = 0 ;
49969 PyObject *swig_obj[1] ;
49970
49971 if (!args) SWIG_fail;
49972 swig_obj[0] = args;
49973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49974 if (!SWIG_IsOK(res1)) {
49975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49976 }
49977 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49978 {
49979 PyThreadState* __tstate = wxPyBeginAllowThreads();
49980 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49981 wxPyEndAllowThreads(__tstate);
49982 if (PyErr_Occurred()) SWIG_fail;
49983 }
49984 resultobj = SWIG_From_int(static_cast< int >(result));
49985 return resultobj;
49986 fail:
49987 return NULL;
49988 }
49989
49990
49991 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49992 PyObject *resultobj = 0;
49993 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49994 wxArrayInt *result = 0 ;
49995 void *argp1 = 0 ;
49996 int res1 = 0 ;
49997 PyObject *swig_obj[1] ;
49998
49999 if (!args) SWIG_fail;
50000 swig_obj[0] = args;
50001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50002 if (!SWIG_IsOK(res1)) {
50003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
50004 }
50005 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50006 {
50007 PyThreadState* __tstate = wxPyBeginAllowThreads();
50008 {
50009 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
50010 result = (wxArrayInt *) &_result_ref;
50011 }
50012 wxPyEndAllowThreads(__tstate);
50013 if (PyErr_Occurred()) SWIG_fail;
50014 }
50015 {
50016 resultobj = wxArrayInt2PyList_helper(*result);
50017 }
50018 return resultobj;
50019 fail:
50020 return NULL;
50021 }
50022
50023
50024 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50025 PyObject *resultobj = 0;
50026 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
50027 wxArrayInt *result = 0 ;
50028 void *argp1 = 0 ;
50029 int res1 = 0 ;
50030 PyObject *swig_obj[1] ;
50031
50032 if (!args) SWIG_fail;
50033 swig_obj[0] = args;
50034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50035 if (!SWIG_IsOK(res1)) {
50036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
50037 }
50038 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50039 {
50040 PyThreadState* __tstate = wxPyBeginAllowThreads();
50041 {
50042 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
50043 result = (wxArrayInt *) &_result_ref;
50044 }
50045 wxPyEndAllowThreads(__tstate);
50046 if (PyErr_Occurred()) SWIG_fail;
50047 }
50048 {
50049 resultobj = wxArrayInt2PyList_helper(*result);
50050 }
50051 return resultobj;
50052 fail:
50053 return NULL;
50054 }
50055
50056
50057 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50058 PyObject *obj;
50059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50060 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
50061 return SWIG_Py_Void();
50062 }
50063
50064 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50065 return SWIG_Python_InitShadowInstance(args);
50066 }
50067
50068 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50069 PyObject *resultobj = 0;
50070 wxStdDialogButtonSizer *result = 0 ;
50071
50072 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
50073 {
50074 PyThreadState* __tstate = wxPyBeginAllowThreads();
50075 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
50076 wxPyEndAllowThreads(__tstate);
50077 if (PyErr_Occurred()) SWIG_fail;
50078 }
50079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
50080 return resultobj;
50081 fail:
50082 return NULL;
50083 }
50084
50085
50086 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50087 PyObject *resultobj = 0;
50088 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50089 wxButton *arg2 = (wxButton *) 0 ;
50090 void *argp1 = 0 ;
50091 int res1 = 0 ;
50092 void *argp2 = 0 ;
50093 int res2 = 0 ;
50094 PyObject * obj0 = 0 ;
50095 PyObject * obj1 = 0 ;
50096 char * kwnames[] = {
50097 (char *) "self",(char *) "button", NULL
50098 };
50099
50100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
50101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50102 if (!SWIG_IsOK(res1)) {
50103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50104 }
50105 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50106 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50107 if (!SWIG_IsOK(res2)) {
50108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
50109 }
50110 arg2 = reinterpret_cast< wxButton * >(argp2);
50111 {
50112 PyThreadState* __tstate = wxPyBeginAllowThreads();
50113 (arg1)->AddButton(arg2);
50114 wxPyEndAllowThreads(__tstate);
50115 if (PyErr_Occurred()) SWIG_fail;
50116 }
50117 resultobj = SWIG_Py_Void();
50118 return resultobj;
50119 fail:
50120 return NULL;
50121 }
50122
50123
50124 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50125 PyObject *resultobj = 0;
50126 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50127 void *argp1 = 0 ;
50128 int res1 = 0 ;
50129 PyObject *swig_obj[1] ;
50130
50131 if (!args) SWIG_fail;
50132 swig_obj[0] = args;
50133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50134 if (!SWIG_IsOK(res1)) {
50135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50136 }
50137 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50138 {
50139 PyThreadState* __tstate = wxPyBeginAllowThreads();
50140 (arg1)->Realize();
50141 wxPyEndAllowThreads(__tstate);
50142 if (PyErr_Occurred()) SWIG_fail;
50143 }
50144 resultobj = SWIG_Py_Void();
50145 return resultobj;
50146 fail:
50147 return NULL;
50148 }
50149
50150
50151 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50152 PyObject *resultobj = 0;
50153 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50154 wxButton *arg2 = (wxButton *) 0 ;
50155 void *argp1 = 0 ;
50156 int res1 = 0 ;
50157 void *argp2 = 0 ;
50158 int res2 = 0 ;
50159 PyObject * obj0 = 0 ;
50160 PyObject * obj1 = 0 ;
50161 char * kwnames[] = {
50162 (char *) "self",(char *) "button", NULL
50163 };
50164
50165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50167 if (!SWIG_IsOK(res1)) {
50168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50169 }
50170 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50171 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50172 if (!SWIG_IsOK(res2)) {
50173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50174 }
50175 arg2 = reinterpret_cast< wxButton * >(argp2);
50176 {
50177 PyThreadState* __tstate = wxPyBeginAllowThreads();
50178 (arg1)->SetAffirmativeButton(arg2);
50179 wxPyEndAllowThreads(__tstate);
50180 if (PyErr_Occurred()) SWIG_fail;
50181 }
50182 resultobj = SWIG_Py_Void();
50183 return resultobj;
50184 fail:
50185 return NULL;
50186 }
50187
50188
50189 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50190 PyObject *resultobj = 0;
50191 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50192 wxButton *arg2 = (wxButton *) 0 ;
50193 void *argp1 = 0 ;
50194 int res1 = 0 ;
50195 void *argp2 = 0 ;
50196 int res2 = 0 ;
50197 PyObject * obj0 = 0 ;
50198 PyObject * obj1 = 0 ;
50199 char * kwnames[] = {
50200 (char *) "self",(char *) "button", NULL
50201 };
50202
50203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50205 if (!SWIG_IsOK(res1)) {
50206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50207 }
50208 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50209 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50210 if (!SWIG_IsOK(res2)) {
50211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50212 }
50213 arg2 = reinterpret_cast< wxButton * >(argp2);
50214 {
50215 PyThreadState* __tstate = wxPyBeginAllowThreads();
50216 (arg1)->SetNegativeButton(arg2);
50217 wxPyEndAllowThreads(__tstate);
50218 if (PyErr_Occurred()) SWIG_fail;
50219 }
50220 resultobj = SWIG_Py_Void();
50221 return resultobj;
50222 fail:
50223 return NULL;
50224 }
50225
50226
50227 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50228 PyObject *resultobj = 0;
50229 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50230 wxButton *arg2 = (wxButton *) 0 ;
50231 void *argp1 = 0 ;
50232 int res1 = 0 ;
50233 void *argp2 = 0 ;
50234 int res2 = 0 ;
50235 PyObject * obj0 = 0 ;
50236 PyObject * obj1 = 0 ;
50237 char * kwnames[] = {
50238 (char *) "self",(char *) "button", NULL
50239 };
50240
50241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
50242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50243 if (!SWIG_IsOK(res1)) {
50244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50245 }
50246 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50248 if (!SWIG_IsOK(res2)) {
50249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
50250 }
50251 arg2 = reinterpret_cast< wxButton * >(argp2);
50252 {
50253 PyThreadState* __tstate = wxPyBeginAllowThreads();
50254 (arg1)->SetCancelButton(arg2);
50255 wxPyEndAllowThreads(__tstate);
50256 if (PyErr_Occurred()) SWIG_fail;
50257 }
50258 resultobj = SWIG_Py_Void();
50259 return resultobj;
50260 fail:
50261 return NULL;
50262 }
50263
50264
50265 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50266 PyObject *resultobj = 0;
50267 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50268 wxButton *result = 0 ;
50269 void *argp1 = 0 ;
50270 int res1 = 0 ;
50271 PyObject *swig_obj[1] ;
50272
50273 if (!args) SWIG_fail;
50274 swig_obj[0] = args;
50275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50276 if (!SWIG_IsOK(res1)) {
50277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50278 }
50279 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50280 {
50281 PyThreadState* __tstate = wxPyBeginAllowThreads();
50282 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
50283 wxPyEndAllowThreads(__tstate);
50284 if (PyErr_Occurred()) SWIG_fail;
50285 }
50286 {
50287 resultobj = wxPyMake_wxObject(result, (bool)0);
50288 }
50289 return resultobj;
50290 fail:
50291 return NULL;
50292 }
50293
50294
50295 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50296 PyObject *resultobj = 0;
50297 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50298 wxButton *result = 0 ;
50299 void *argp1 = 0 ;
50300 int res1 = 0 ;
50301 PyObject *swig_obj[1] ;
50302
50303 if (!args) SWIG_fail;
50304 swig_obj[0] = args;
50305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50306 if (!SWIG_IsOK(res1)) {
50307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50308 }
50309 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50310 {
50311 PyThreadState* __tstate = wxPyBeginAllowThreads();
50312 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
50313 wxPyEndAllowThreads(__tstate);
50314 if (PyErr_Occurred()) SWIG_fail;
50315 }
50316 {
50317 resultobj = wxPyMake_wxObject(result, (bool)0);
50318 }
50319 return resultobj;
50320 fail:
50321 return NULL;
50322 }
50323
50324
50325 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50326 PyObject *resultobj = 0;
50327 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50328 wxButton *result = 0 ;
50329 void *argp1 = 0 ;
50330 int res1 = 0 ;
50331 PyObject *swig_obj[1] ;
50332
50333 if (!args) SWIG_fail;
50334 swig_obj[0] = args;
50335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50336 if (!SWIG_IsOK(res1)) {
50337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50338 }
50339 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50340 {
50341 PyThreadState* __tstate = wxPyBeginAllowThreads();
50342 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
50343 wxPyEndAllowThreads(__tstate);
50344 if (PyErr_Occurred()) SWIG_fail;
50345 }
50346 {
50347 resultobj = wxPyMake_wxObject(result, (bool)0);
50348 }
50349 return resultobj;
50350 fail:
50351 return NULL;
50352 }
50353
50354
50355 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50356 PyObject *resultobj = 0;
50357 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50358 wxButton *result = 0 ;
50359 void *argp1 = 0 ;
50360 int res1 = 0 ;
50361 PyObject *swig_obj[1] ;
50362
50363 if (!args) SWIG_fail;
50364 swig_obj[0] = args;
50365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50366 if (!SWIG_IsOK(res1)) {
50367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50368 }
50369 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50370 {
50371 PyThreadState* __tstate = wxPyBeginAllowThreads();
50372 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
50373 wxPyEndAllowThreads(__tstate);
50374 if (PyErr_Occurred()) SWIG_fail;
50375 }
50376 {
50377 resultobj = wxPyMake_wxObject(result, (bool)0);
50378 }
50379 return resultobj;
50380 fail:
50381 return NULL;
50382 }
50383
50384
50385 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50386 PyObject *resultobj = 0;
50387 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50388 wxButton *result = 0 ;
50389 void *argp1 = 0 ;
50390 int res1 = 0 ;
50391 PyObject *swig_obj[1] ;
50392
50393 if (!args) SWIG_fail;
50394 swig_obj[0] = args;
50395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50396 if (!SWIG_IsOK(res1)) {
50397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50398 }
50399 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50400 {
50401 PyThreadState* __tstate = wxPyBeginAllowThreads();
50402 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
50403 wxPyEndAllowThreads(__tstate);
50404 if (PyErr_Occurred()) SWIG_fail;
50405 }
50406 {
50407 resultobj = wxPyMake_wxObject(result, (bool)0);
50408 }
50409 return resultobj;
50410 fail:
50411 return NULL;
50412 }
50413
50414
50415 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50416 PyObject *obj;
50417 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50418 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
50419 return SWIG_Py_Void();
50420 }
50421
50422 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50423 return SWIG_Python_InitShadowInstance(args);
50424 }
50425
50426 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50427 PyObject *resultobj = 0;
50428 int arg1 = (int) 0 ;
50429 int arg2 = (int) 0 ;
50430 wxGBPosition *result = 0 ;
50431 int val1 ;
50432 int ecode1 = 0 ;
50433 int val2 ;
50434 int ecode2 = 0 ;
50435 PyObject * obj0 = 0 ;
50436 PyObject * obj1 = 0 ;
50437 char * kwnames[] = {
50438 (char *) "row",(char *) "col", NULL
50439 };
50440
50441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50442 if (obj0) {
50443 ecode1 = SWIG_AsVal_int(obj0, &val1);
50444 if (!SWIG_IsOK(ecode1)) {
50445 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
50446 }
50447 arg1 = static_cast< int >(val1);
50448 }
50449 if (obj1) {
50450 ecode2 = SWIG_AsVal_int(obj1, &val2);
50451 if (!SWIG_IsOK(ecode2)) {
50452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
50453 }
50454 arg2 = static_cast< int >(val2);
50455 }
50456 {
50457 PyThreadState* __tstate = wxPyBeginAllowThreads();
50458 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
50459 wxPyEndAllowThreads(__tstate);
50460 if (PyErr_Occurred()) SWIG_fail;
50461 }
50462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
50463 return resultobj;
50464 fail:
50465 return NULL;
50466 }
50467
50468
50469 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50470 PyObject *resultobj = 0;
50471 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50472 void *argp1 = 0 ;
50473 int res1 = 0 ;
50474 PyObject *swig_obj[1] ;
50475
50476 if (!args) SWIG_fail;
50477 swig_obj[0] = args;
50478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
50479 if (!SWIG_IsOK(res1)) {
50480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50481 }
50482 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50483 {
50484 PyThreadState* __tstate = wxPyBeginAllowThreads();
50485 delete arg1;
50486
50487 wxPyEndAllowThreads(__tstate);
50488 if (PyErr_Occurred()) SWIG_fail;
50489 }
50490 resultobj = SWIG_Py_Void();
50491 return resultobj;
50492 fail:
50493 return NULL;
50494 }
50495
50496
50497 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50498 PyObject *resultobj = 0;
50499 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50500 int result;
50501 void *argp1 = 0 ;
50502 int res1 = 0 ;
50503 PyObject *swig_obj[1] ;
50504
50505 if (!args) SWIG_fail;
50506 swig_obj[0] = args;
50507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50508 if (!SWIG_IsOK(res1)) {
50509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50510 }
50511 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50512 {
50513 PyThreadState* __tstate = wxPyBeginAllowThreads();
50514 result = (int)((wxGBPosition const *)arg1)->GetRow();
50515 wxPyEndAllowThreads(__tstate);
50516 if (PyErr_Occurred()) SWIG_fail;
50517 }
50518 resultobj = SWIG_From_int(static_cast< int >(result));
50519 return resultobj;
50520 fail:
50521 return NULL;
50522 }
50523
50524
50525 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50526 PyObject *resultobj = 0;
50527 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50528 int result;
50529 void *argp1 = 0 ;
50530 int res1 = 0 ;
50531 PyObject *swig_obj[1] ;
50532
50533 if (!args) SWIG_fail;
50534 swig_obj[0] = args;
50535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50536 if (!SWIG_IsOK(res1)) {
50537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50538 }
50539 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50540 {
50541 PyThreadState* __tstate = wxPyBeginAllowThreads();
50542 result = (int)((wxGBPosition const *)arg1)->GetCol();
50543 wxPyEndAllowThreads(__tstate);
50544 if (PyErr_Occurred()) SWIG_fail;
50545 }
50546 resultobj = SWIG_From_int(static_cast< int >(result));
50547 return resultobj;
50548 fail:
50549 return NULL;
50550 }
50551
50552
50553 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50554 PyObject *resultobj = 0;
50555 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50556 int arg2 ;
50557 void *argp1 = 0 ;
50558 int res1 = 0 ;
50559 int val2 ;
50560 int ecode2 = 0 ;
50561 PyObject * obj0 = 0 ;
50562 PyObject * obj1 = 0 ;
50563 char * kwnames[] = {
50564 (char *) "self",(char *) "row", NULL
50565 };
50566
50567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50569 if (!SWIG_IsOK(res1)) {
50570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50571 }
50572 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50573 ecode2 = SWIG_AsVal_int(obj1, &val2);
50574 if (!SWIG_IsOK(ecode2)) {
50575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50576 }
50577 arg2 = static_cast< int >(val2);
50578 {
50579 PyThreadState* __tstate = wxPyBeginAllowThreads();
50580 (arg1)->SetRow(arg2);
50581 wxPyEndAllowThreads(__tstate);
50582 if (PyErr_Occurred()) SWIG_fail;
50583 }
50584 resultobj = SWIG_Py_Void();
50585 return resultobj;
50586 fail:
50587 return NULL;
50588 }
50589
50590
50591 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50592 PyObject *resultobj = 0;
50593 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50594 int arg2 ;
50595 void *argp1 = 0 ;
50596 int res1 = 0 ;
50597 int val2 ;
50598 int ecode2 = 0 ;
50599 PyObject * obj0 = 0 ;
50600 PyObject * obj1 = 0 ;
50601 char * kwnames[] = {
50602 (char *) "self",(char *) "col", NULL
50603 };
50604
50605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50607 if (!SWIG_IsOK(res1)) {
50608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50609 }
50610 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50611 ecode2 = SWIG_AsVal_int(obj1, &val2);
50612 if (!SWIG_IsOK(ecode2)) {
50613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50614 }
50615 arg2 = static_cast< int >(val2);
50616 {
50617 PyThreadState* __tstate = wxPyBeginAllowThreads();
50618 (arg1)->SetCol(arg2);
50619 wxPyEndAllowThreads(__tstate);
50620 if (PyErr_Occurred()) SWIG_fail;
50621 }
50622 resultobj = SWIG_Py_Void();
50623 return resultobj;
50624 fail:
50625 return NULL;
50626 }
50627
50628
50629 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50630 PyObject *resultobj = 0;
50631 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50632 PyObject *arg2 = (PyObject *) 0 ;
50633 bool result;
50634 void *argp1 = 0 ;
50635 int res1 = 0 ;
50636 PyObject * obj0 = 0 ;
50637 PyObject * obj1 = 0 ;
50638 char * kwnames[] = {
50639 (char *) "self",(char *) "other", NULL
50640 };
50641
50642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50644 if (!SWIG_IsOK(res1)) {
50645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50646 }
50647 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50648 arg2 = obj1;
50649 {
50650 result = (bool)wxGBPosition___eq__(arg1,arg2);
50651 if (PyErr_Occurred()) SWIG_fail;
50652 }
50653 {
50654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50655 }
50656 return resultobj;
50657 fail:
50658 return NULL;
50659 }
50660
50661
50662 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50663 PyObject *resultobj = 0;
50664 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50665 PyObject *arg2 = (PyObject *) 0 ;
50666 bool result;
50667 void *argp1 = 0 ;
50668 int res1 = 0 ;
50669 PyObject * obj0 = 0 ;
50670 PyObject * obj1 = 0 ;
50671 char * kwnames[] = {
50672 (char *) "self",(char *) "other", NULL
50673 };
50674
50675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50677 if (!SWIG_IsOK(res1)) {
50678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50679 }
50680 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50681 arg2 = obj1;
50682 {
50683 result = (bool)wxGBPosition___ne__(arg1,arg2);
50684 if (PyErr_Occurred()) SWIG_fail;
50685 }
50686 {
50687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50688 }
50689 return resultobj;
50690 fail:
50691 return NULL;
50692 }
50693
50694
50695 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50696 PyObject *resultobj = 0;
50697 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50698 int arg2 = (int) 0 ;
50699 int arg3 = (int) 0 ;
50700 void *argp1 = 0 ;
50701 int res1 = 0 ;
50702 int val2 ;
50703 int ecode2 = 0 ;
50704 int val3 ;
50705 int ecode3 = 0 ;
50706 PyObject * obj0 = 0 ;
50707 PyObject * obj1 = 0 ;
50708 PyObject * obj2 = 0 ;
50709 char * kwnames[] = {
50710 (char *) "self",(char *) "row",(char *) "col", NULL
50711 };
50712
50713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50715 if (!SWIG_IsOK(res1)) {
50716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50717 }
50718 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50719 if (obj1) {
50720 ecode2 = SWIG_AsVal_int(obj1, &val2);
50721 if (!SWIG_IsOK(ecode2)) {
50722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50723 }
50724 arg2 = static_cast< int >(val2);
50725 }
50726 if (obj2) {
50727 ecode3 = SWIG_AsVal_int(obj2, &val3);
50728 if (!SWIG_IsOK(ecode3)) {
50729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50730 }
50731 arg3 = static_cast< int >(val3);
50732 }
50733 {
50734 PyThreadState* __tstate = wxPyBeginAllowThreads();
50735 wxGBPosition_Set(arg1,arg2,arg3);
50736 wxPyEndAllowThreads(__tstate);
50737 if (PyErr_Occurred()) SWIG_fail;
50738 }
50739 resultobj = SWIG_Py_Void();
50740 return resultobj;
50741 fail:
50742 return NULL;
50743 }
50744
50745
50746 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50747 PyObject *resultobj = 0;
50748 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50749 PyObject *result = 0 ;
50750 void *argp1 = 0 ;
50751 int res1 = 0 ;
50752 PyObject *swig_obj[1] ;
50753
50754 if (!args) SWIG_fail;
50755 swig_obj[0] = args;
50756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50757 if (!SWIG_IsOK(res1)) {
50758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50759 }
50760 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50761 {
50762 PyThreadState* __tstate = wxPyBeginAllowThreads();
50763 result = (PyObject *)wxGBPosition_Get(arg1);
50764 wxPyEndAllowThreads(__tstate);
50765 if (PyErr_Occurred()) SWIG_fail;
50766 }
50767 resultobj = result;
50768 return resultobj;
50769 fail:
50770 return NULL;
50771 }
50772
50773
50774 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50775 PyObject *obj;
50776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50777 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50778 return SWIG_Py_Void();
50779 }
50780
50781 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50782 return SWIG_Python_InitShadowInstance(args);
50783 }
50784
50785 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50786 PyObject *resultobj = 0;
50787 int arg1 = (int) 1 ;
50788 int arg2 = (int) 1 ;
50789 wxGBSpan *result = 0 ;
50790 int val1 ;
50791 int ecode1 = 0 ;
50792 int val2 ;
50793 int ecode2 = 0 ;
50794 PyObject * obj0 = 0 ;
50795 PyObject * obj1 = 0 ;
50796 char * kwnames[] = {
50797 (char *) "rowspan",(char *) "colspan", NULL
50798 };
50799
50800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50801 if (obj0) {
50802 ecode1 = SWIG_AsVal_int(obj0, &val1);
50803 if (!SWIG_IsOK(ecode1)) {
50804 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50805 }
50806 arg1 = static_cast< int >(val1);
50807 }
50808 if (obj1) {
50809 ecode2 = SWIG_AsVal_int(obj1, &val2);
50810 if (!SWIG_IsOK(ecode2)) {
50811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50812 }
50813 arg2 = static_cast< int >(val2);
50814 }
50815 {
50816 PyThreadState* __tstate = wxPyBeginAllowThreads();
50817 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50818 wxPyEndAllowThreads(__tstate);
50819 if (PyErr_Occurred()) SWIG_fail;
50820 }
50821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50822 return resultobj;
50823 fail:
50824 return NULL;
50825 }
50826
50827
50828 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50829 PyObject *resultobj = 0;
50830 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50831 void *argp1 = 0 ;
50832 int res1 = 0 ;
50833 PyObject *swig_obj[1] ;
50834
50835 if (!args) SWIG_fail;
50836 swig_obj[0] = args;
50837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50838 if (!SWIG_IsOK(res1)) {
50839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50840 }
50841 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50842 {
50843 PyThreadState* __tstate = wxPyBeginAllowThreads();
50844 delete arg1;
50845
50846 wxPyEndAllowThreads(__tstate);
50847 if (PyErr_Occurred()) SWIG_fail;
50848 }
50849 resultobj = SWIG_Py_Void();
50850 return resultobj;
50851 fail:
50852 return NULL;
50853 }
50854
50855
50856 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50857 PyObject *resultobj = 0;
50858 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50859 int result;
50860 void *argp1 = 0 ;
50861 int res1 = 0 ;
50862 PyObject *swig_obj[1] ;
50863
50864 if (!args) SWIG_fail;
50865 swig_obj[0] = args;
50866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50867 if (!SWIG_IsOK(res1)) {
50868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50869 }
50870 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50871 {
50872 PyThreadState* __tstate = wxPyBeginAllowThreads();
50873 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50874 wxPyEndAllowThreads(__tstate);
50875 if (PyErr_Occurred()) SWIG_fail;
50876 }
50877 resultobj = SWIG_From_int(static_cast< int >(result));
50878 return resultobj;
50879 fail:
50880 return NULL;
50881 }
50882
50883
50884 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50885 PyObject *resultobj = 0;
50886 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50887 int result;
50888 void *argp1 = 0 ;
50889 int res1 = 0 ;
50890 PyObject *swig_obj[1] ;
50891
50892 if (!args) SWIG_fail;
50893 swig_obj[0] = args;
50894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50895 if (!SWIG_IsOK(res1)) {
50896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50897 }
50898 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50899 {
50900 PyThreadState* __tstate = wxPyBeginAllowThreads();
50901 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50902 wxPyEndAllowThreads(__tstate);
50903 if (PyErr_Occurred()) SWIG_fail;
50904 }
50905 resultobj = SWIG_From_int(static_cast< int >(result));
50906 return resultobj;
50907 fail:
50908 return NULL;
50909 }
50910
50911
50912 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50913 PyObject *resultobj = 0;
50914 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50915 int arg2 ;
50916 void *argp1 = 0 ;
50917 int res1 = 0 ;
50918 int val2 ;
50919 int ecode2 = 0 ;
50920 PyObject * obj0 = 0 ;
50921 PyObject * obj1 = 0 ;
50922 char * kwnames[] = {
50923 (char *) "self",(char *) "rowspan", NULL
50924 };
50925
50926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50928 if (!SWIG_IsOK(res1)) {
50929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50930 }
50931 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50932 ecode2 = SWIG_AsVal_int(obj1, &val2);
50933 if (!SWIG_IsOK(ecode2)) {
50934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50935 }
50936 arg2 = static_cast< int >(val2);
50937 {
50938 PyThreadState* __tstate = wxPyBeginAllowThreads();
50939 (arg1)->SetRowspan(arg2);
50940 wxPyEndAllowThreads(__tstate);
50941 if (PyErr_Occurred()) SWIG_fail;
50942 }
50943 resultobj = SWIG_Py_Void();
50944 return resultobj;
50945 fail:
50946 return NULL;
50947 }
50948
50949
50950 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50951 PyObject *resultobj = 0;
50952 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50953 int arg2 ;
50954 void *argp1 = 0 ;
50955 int res1 = 0 ;
50956 int val2 ;
50957 int ecode2 = 0 ;
50958 PyObject * obj0 = 0 ;
50959 PyObject * obj1 = 0 ;
50960 char * kwnames[] = {
50961 (char *) "self",(char *) "colspan", NULL
50962 };
50963
50964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50966 if (!SWIG_IsOK(res1)) {
50967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50968 }
50969 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50970 ecode2 = SWIG_AsVal_int(obj1, &val2);
50971 if (!SWIG_IsOK(ecode2)) {
50972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50973 }
50974 arg2 = static_cast< int >(val2);
50975 {
50976 PyThreadState* __tstate = wxPyBeginAllowThreads();
50977 (arg1)->SetColspan(arg2);
50978 wxPyEndAllowThreads(__tstate);
50979 if (PyErr_Occurred()) SWIG_fail;
50980 }
50981 resultobj = SWIG_Py_Void();
50982 return resultobj;
50983 fail:
50984 return NULL;
50985 }
50986
50987
50988 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50989 PyObject *resultobj = 0;
50990 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50991 PyObject *arg2 = (PyObject *) 0 ;
50992 bool result;
50993 void *argp1 = 0 ;
50994 int res1 = 0 ;
50995 PyObject * obj0 = 0 ;
50996 PyObject * obj1 = 0 ;
50997 char * kwnames[] = {
50998 (char *) "self",(char *) "other", NULL
50999 };
51000
51001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
51002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51003 if (!SWIG_IsOK(res1)) {
51004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51005 }
51006 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51007 arg2 = obj1;
51008 {
51009 result = (bool)wxGBSpan___eq__(arg1,arg2);
51010 if (PyErr_Occurred()) SWIG_fail;
51011 }
51012 {
51013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51014 }
51015 return resultobj;
51016 fail:
51017 return NULL;
51018 }
51019
51020
51021 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51022 PyObject *resultobj = 0;
51023 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51024 PyObject *arg2 = (PyObject *) 0 ;
51025 bool result;
51026 void *argp1 = 0 ;
51027 int res1 = 0 ;
51028 PyObject * obj0 = 0 ;
51029 PyObject * obj1 = 0 ;
51030 char * kwnames[] = {
51031 (char *) "self",(char *) "other", NULL
51032 };
51033
51034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
51035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51036 if (!SWIG_IsOK(res1)) {
51037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51038 }
51039 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51040 arg2 = obj1;
51041 {
51042 result = (bool)wxGBSpan___ne__(arg1,arg2);
51043 if (PyErr_Occurred()) SWIG_fail;
51044 }
51045 {
51046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51047 }
51048 return resultobj;
51049 fail:
51050 return NULL;
51051 }
51052
51053
51054 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51055 PyObject *resultobj = 0;
51056 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51057 int arg2 = (int) 1 ;
51058 int arg3 = (int) 1 ;
51059 void *argp1 = 0 ;
51060 int res1 = 0 ;
51061 int val2 ;
51062 int ecode2 = 0 ;
51063 int val3 ;
51064 int ecode3 = 0 ;
51065 PyObject * obj0 = 0 ;
51066 PyObject * obj1 = 0 ;
51067 PyObject * obj2 = 0 ;
51068 char * kwnames[] = {
51069 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
51070 };
51071
51072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51074 if (!SWIG_IsOK(res1)) {
51075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51076 }
51077 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51078 if (obj1) {
51079 ecode2 = SWIG_AsVal_int(obj1, &val2);
51080 if (!SWIG_IsOK(ecode2)) {
51081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
51082 }
51083 arg2 = static_cast< int >(val2);
51084 }
51085 if (obj2) {
51086 ecode3 = SWIG_AsVal_int(obj2, &val3);
51087 if (!SWIG_IsOK(ecode3)) {
51088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
51089 }
51090 arg3 = static_cast< int >(val3);
51091 }
51092 {
51093 PyThreadState* __tstate = wxPyBeginAllowThreads();
51094 wxGBSpan_Set(arg1,arg2,arg3);
51095 wxPyEndAllowThreads(__tstate);
51096 if (PyErr_Occurred()) SWIG_fail;
51097 }
51098 resultobj = SWIG_Py_Void();
51099 return resultobj;
51100 fail:
51101 return NULL;
51102 }
51103
51104
51105 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51106 PyObject *resultobj = 0;
51107 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51108 PyObject *result = 0 ;
51109 void *argp1 = 0 ;
51110 int res1 = 0 ;
51111 PyObject *swig_obj[1] ;
51112
51113 if (!args) SWIG_fail;
51114 swig_obj[0] = args;
51115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51116 if (!SWIG_IsOK(res1)) {
51117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51118 }
51119 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51120 {
51121 PyThreadState* __tstate = wxPyBeginAllowThreads();
51122 result = (PyObject *)wxGBSpan_Get(arg1);
51123 wxPyEndAllowThreads(__tstate);
51124 if (PyErr_Occurred()) SWIG_fail;
51125 }
51126 resultobj = result;
51127 return resultobj;
51128 fail:
51129 return NULL;
51130 }
51131
51132
51133 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51134 PyObject *obj;
51135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51136 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
51137 return SWIG_Py_Void();
51138 }
51139
51140 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51141 return SWIG_Python_InitShadowInstance(args);
51142 }
51143
51144 SWIGINTERN int DefaultSpan_set(PyObject *) {
51145 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
51146 return 1;
51147 }
51148
51149
51150 SWIGINTERN PyObject *DefaultSpan_get(void) {
51151 PyObject *pyobj = 0;
51152
51153 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
51154 return pyobj;
51155 }
51156
51157
51158 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51159 PyObject *resultobj = 0;
51160 wxGBSizerItem *result = 0 ;
51161
51162 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
51163 {
51164 PyThreadState* __tstate = wxPyBeginAllowThreads();
51165 result = (wxGBSizerItem *)new wxGBSizerItem();
51166 wxPyEndAllowThreads(__tstate);
51167 if (PyErr_Occurred()) SWIG_fail;
51168 }
51169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
51170 return resultobj;
51171 fail:
51172 return NULL;
51173 }
51174
51175
51176 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51177 PyObject *resultobj = 0;
51178 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51179 void *argp1 = 0 ;
51180 int res1 = 0 ;
51181 PyObject *swig_obj[1] ;
51182
51183 if (!args) SWIG_fail;
51184 swig_obj[0] = args;
51185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51186 if (!SWIG_IsOK(res1)) {
51187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51188 }
51189 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51190 {
51191 PyThreadState* __tstate = wxPyBeginAllowThreads();
51192 delete arg1;
51193
51194 wxPyEndAllowThreads(__tstate);
51195 if (PyErr_Occurred()) SWIG_fail;
51196 }
51197 resultobj = SWIG_Py_Void();
51198 return resultobj;
51199 fail:
51200 return NULL;
51201 }
51202
51203
51204 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51205 PyObject *resultobj = 0;
51206 wxWindow *arg1 = (wxWindow *) 0 ;
51207 wxGBPosition *arg2 = 0 ;
51208 wxGBSpan *arg3 = 0 ;
51209 int arg4 ;
51210 int arg5 ;
51211 PyObject *arg6 = (PyObject *) NULL ;
51212 wxGBSizerItem *result = 0 ;
51213 void *argp1 = 0 ;
51214 int res1 = 0 ;
51215 wxGBPosition temp2 ;
51216 wxGBSpan temp3 ;
51217 int val4 ;
51218 int ecode4 = 0 ;
51219 int val5 ;
51220 int ecode5 = 0 ;
51221 PyObject * obj0 = 0 ;
51222 PyObject * obj1 = 0 ;
51223 PyObject * obj2 = 0 ;
51224 PyObject * obj3 = 0 ;
51225 PyObject * obj4 = 0 ;
51226 PyObject * obj5 = 0 ;
51227 char * kwnames[] = {
51228 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51229 };
51230
51231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
51233 if (!SWIG_IsOK(res1)) {
51234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
51235 }
51236 arg1 = reinterpret_cast< wxWindow * >(argp1);
51237 {
51238 arg2 = &temp2;
51239 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51240 }
51241 {
51242 arg3 = &temp3;
51243 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51244 }
51245 ecode4 = SWIG_AsVal_int(obj3, &val4);
51246 if (!SWIG_IsOK(ecode4)) {
51247 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
51248 }
51249 arg4 = static_cast< int >(val4);
51250 ecode5 = SWIG_AsVal_int(obj4, &val5);
51251 if (!SWIG_IsOK(ecode5)) {
51252 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
51253 }
51254 arg5 = static_cast< int >(val5);
51255 if (obj5) {
51256 arg6 = obj5;
51257 }
51258 {
51259 PyThreadState* __tstate = wxPyBeginAllowThreads();
51260 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51261 wxPyEndAllowThreads(__tstate);
51262 if (PyErr_Occurred()) SWIG_fail;
51263 }
51264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51265 return resultobj;
51266 fail:
51267 return NULL;
51268 }
51269
51270
51271 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51272 PyObject *resultobj = 0;
51273 wxSizer *arg1 = (wxSizer *) 0 ;
51274 wxGBPosition *arg2 = 0 ;
51275 wxGBSpan *arg3 = 0 ;
51276 int arg4 ;
51277 int arg5 ;
51278 PyObject *arg6 = (PyObject *) NULL ;
51279 wxGBSizerItem *result = 0 ;
51280 int res1 = 0 ;
51281 wxGBPosition temp2 ;
51282 wxGBSpan temp3 ;
51283 int val4 ;
51284 int ecode4 = 0 ;
51285 int val5 ;
51286 int ecode5 = 0 ;
51287 PyObject * obj0 = 0 ;
51288 PyObject * obj1 = 0 ;
51289 PyObject * obj2 = 0 ;
51290 PyObject * obj3 = 0 ;
51291 PyObject * obj4 = 0 ;
51292 PyObject * obj5 = 0 ;
51293 char * kwnames[] = {
51294 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51295 };
51296
51297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51298 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51299 if (!SWIG_IsOK(res1)) {
51300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51301 }
51302 {
51303 arg2 = &temp2;
51304 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51305 }
51306 {
51307 arg3 = &temp3;
51308 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51309 }
51310 ecode4 = SWIG_AsVal_int(obj3, &val4);
51311 if (!SWIG_IsOK(ecode4)) {
51312 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
51313 }
51314 arg4 = static_cast< int >(val4);
51315 ecode5 = SWIG_AsVal_int(obj4, &val5);
51316 if (!SWIG_IsOK(ecode5)) {
51317 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
51318 }
51319 arg5 = static_cast< int >(val5);
51320 if (obj5) {
51321 arg6 = obj5;
51322 }
51323 {
51324 PyThreadState* __tstate = wxPyBeginAllowThreads();
51325 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51326 wxPyEndAllowThreads(__tstate);
51327 if (PyErr_Occurred()) SWIG_fail;
51328 }
51329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51330 return resultobj;
51331 fail:
51332 return NULL;
51333 }
51334
51335
51336 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51337 PyObject *resultobj = 0;
51338 int arg1 ;
51339 int arg2 ;
51340 wxGBPosition *arg3 = 0 ;
51341 wxGBSpan *arg4 = 0 ;
51342 int arg5 ;
51343 int arg6 ;
51344 PyObject *arg7 = (PyObject *) NULL ;
51345 wxGBSizerItem *result = 0 ;
51346 int val1 ;
51347 int ecode1 = 0 ;
51348 int val2 ;
51349 int ecode2 = 0 ;
51350 wxGBPosition temp3 ;
51351 wxGBSpan temp4 ;
51352 int val5 ;
51353 int ecode5 = 0 ;
51354 int val6 ;
51355 int ecode6 = 0 ;
51356 PyObject * obj0 = 0 ;
51357 PyObject * obj1 = 0 ;
51358 PyObject * obj2 = 0 ;
51359 PyObject * obj3 = 0 ;
51360 PyObject * obj4 = 0 ;
51361 PyObject * obj5 = 0 ;
51362 PyObject * obj6 = 0 ;
51363 char * kwnames[] = {
51364 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51365 };
51366
51367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51368 ecode1 = SWIG_AsVal_int(obj0, &val1);
51369 if (!SWIG_IsOK(ecode1)) {
51370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
51371 }
51372 arg1 = static_cast< int >(val1);
51373 ecode2 = SWIG_AsVal_int(obj1, &val2);
51374 if (!SWIG_IsOK(ecode2)) {
51375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
51376 }
51377 arg2 = static_cast< int >(val2);
51378 {
51379 arg3 = &temp3;
51380 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51381 }
51382 {
51383 arg4 = &temp4;
51384 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51385 }
51386 ecode5 = SWIG_AsVal_int(obj4, &val5);
51387 if (!SWIG_IsOK(ecode5)) {
51388 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
51389 }
51390 arg5 = static_cast< int >(val5);
51391 ecode6 = SWIG_AsVal_int(obj5, &val6);
51392 if (!SWIG_IsOK(ecode6)) {
51393 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
51394 }
51395 arg6 = static_cast< int >(val6);
51396 if (obj6) {
51397 arg7 = obj6;
51398 }
51399 {
51400 PyThreadState* __tstate = wxPyBeginAllowThreads();
51401 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51402 wxPyEndAllowThreads(__tstate);
51403 if (PyErr_Occurred()) SWIG_fail;
51404 }
51405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51406 return resultobj;
51407 fail:
51408 return NULL;
51409 }
51410
51411
51412 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51413 PyObject *resultobj = 0;
51414 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51415 wxGBPosition result;
51416 void *argp1 = 0 ;
51417 int res1 = 0 ;
51418 PyObject *swig_obj[1] ;
51419
51420 if (!args) SWIG_fail;
51421 swig_obj[0] = args;
51422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51423 if (!SWIG_IsOK(res1)) {
51424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51425 }
51426 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51427 {
51428 PyThreadState* __tstate = wxPyBeginAllowThreads();
51429 result = ((wxGBSizerItem const *)arg1)->GetPos();
51430 wxPyEndAllowThreads(__tstate);
51431 if (PyErr_Occurred()) SWIG_fail;
51432 }
51433 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51434 return resultobj;
51435 fail:
51436 return NULL;
51437 }
51438
51439
51440 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51441 PyObject *resultobj = 0;
51442 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51443 wxGBSpan result;
51444 void *argp1 = 0 ;
51445 int res1 = 0 ;
51446 PyObject *swig_obj[1] ;
51447
51448 if (!args) SWIG_fail;
51449 swig_obj[0] = args;
51450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51451 if (!SWIG_IsOK(res1)) {
51452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51453 }
51454 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51455 {
51456 PyThreadState* __tstate = wxPyBeginAllowThreads();
51457 result = ((wxGBSizerItem const *)arg1)->GetSpan();
51458 wxPyEndAllowThreads(__tstate);
51459 if (PyErr_Occurred()) SWIG_fail;
51460 }
51461 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51462 return resultobj;
51463 fail:
51464 return NULL;
51465 }
51466
51467
51468 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51469 PyObject *resultobj = 0;
51470 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51471 wxGBPosition *arg2 = 0 ;
51472 bool result;
51473 void *argp1 = 0 ;
51474 int res1 = 0 ;
51475 wxGBPosition temp2 ;
51476 PyObject * obj0 = 0 ;
51477 PyObject * obj1 = 0 ;
51478 char * kwnames[] = {
51479 (char *) "self",(char *) "pos", NULL
51480 };
51481
51482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
51483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51484 if (!SWIG_IsOK(res1)) {
51485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51486 }
51487 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51488 {
51489 arg2 = &temp2;
51490 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51491 }
51492 {
51493 PyThreadState* __tstate = wxPyBeginAllowThreads();
51494 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
51495 wxPyEndAllowThreads(__tstate);
51496 if (PyErr_Occurred()) SWIG_fail;
51497 }
51498 {
51499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51500 }
51501 return resultobj;
51502 fail:
51503 return NULL;
51504 }
51505
51506
51507 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51508 PyObject *resultobj = 0;
51509 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51510 wxGBSpan *arg2 = 0 ;
51511 bool result;
51512 void *argp1 = 0 ;
51513 int res1 = 0 ;
51514 wxGBSpan temp2 ;
51515 PyObject * obj0 = 0 ;
51516 PyObject * obj1 = 0 ;
51517 char * kwnames[] = {
51518 (char *) "self",(char *) "span", NULL
51519 };
51520
51521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
51522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51523 if (!SWIG_IsOK(res1)) {
51524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51525 }
51526 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51527 {
51528 arg2 = &temp2;
51529 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
51530 }
51531 {
51532 PyThreadState* __tstate = wxPyBeginAllowThreads();
51533 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51534 wxPyEndAllowThreads(__tstate);
51535 if (PyErr_Occurred()) SWIG_fail;
51536 }
51537 {
51538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51539 }
51540 return resultobj;
51541 fail:
51542 return NULL;
51543 }
51544
51545
51546 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51547 PyObject *resultobj = 0;
51548 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51549 wxGBSizerItem *arg2 = 0 ;
51550 bool result;
51551 void *argp1 = 0 ;
51552 int res1 = 0 ;
51553 void *argp2 = 0 ;
51554 int res2 = 0 ;
51555 PyObject * obj0 = 0 ;
51556 PyObject * obj1 = 0 ;
51557 char * kwnames[] = {
51558 (char *) "self",(char *) "other", NULL
51559 };
51560
51561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51563 if (!SWIG_IsOK(res1)) {
51564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51565 }
51566 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51567 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51568 if (!SWIG_IsOK(res2)) {
51569 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51570 }
51571 if (!argp2) {
51572 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51573 }
51574 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51575 {
51576 PyThreadState* __tstate = wxPyBeginAllowThreads();
51577 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51578 wxPyEndAllowThreads(__tstate);
51579 if (PyErr_Occurred()) SWIG_fail;
51580 }
51581 {
51582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51583 }
51584 return resultobj;
51585 fail:
51586 return NULL;
51587 }
51588
51589
51590 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51591 PyObject *resultobj = 0;
51592 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51593 wxGBPosition *arg2 = 0 ;
51594 wxGBSpan *arg3 = 0 ;
51595 bool result;
51596 void *argp1 = 0 ;
51597 int res1 = 0 ;
51598 wxGBPosition temp2 ;
51599 wxGBSpan temp3 ;
51600 PyObject * obj0 = 0 ;
51601 PyObject * obj1 = 0 ;
51602 PyObject * obj2 = 0 ;
51603 char * kwnames[] = {
51604 (char *) "self",(char *) "pos",(char *) "span", NULL
51605 };
51606
51607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51609 if (!SWIG_IsOK(res1)) {
51610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51611 }
51612 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51613 {
51614 arg2 = &temp2;
51615 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51616 }
51617 {
51618 arg3 = &temp3;
51619 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51620 }
51621 {
51622 PyThreadState* __tstate = wxPyBeginAllowThreads();
51623 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51624 wxPyEndAllowThreads(__tstate);
51625 if (PyErr_Occurred()) SWIG_fail;
51626 }
51627 {
51628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51629 }
51630 return resultobj;
51631 fail:
51632 return NULL;
51633 }
51634
51635
51636 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51637 PyObject *resultobj = 0;
51638 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51639 wxGBPosition result;
51640 void *argp1 = 0 ;
51641 int res1 = 0 ;
51642 PyObject *swig_obj[1] ;
51643
51644 if (!args) SWIG_fail;
51645 swig_obj[0] = args;
51646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51647 if (!SWIG_IsOK(res1)) {
51648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51649 }
51650 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51651 {
51652 PyThreadState* __tstate = wxPyBeginAllowThreads();
51653 result = wxGBSizerItem_GetEndPos(arg1);
51654 wxPyEndAllowThreads(__tstate);
51655 if (PyErr_Occurred()) SWIG_fail;
51656 }
51657 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51658 return resultobj;
51659 fail:
51660 return NULL;
51661 }
51662
51663
51664 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51665 PyObject *resultobj = 0;
51666 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51667 wxGridBagSizer *result = 0 ;
51668 void *argp1 = 0 ;
51669 int res1 = 0 ;
51670 PyObject *swig_obj[1] ;
51671
51672 if (!args) SWIG_fail;
51673 swig_obj[0] = args;
51674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51675 if (!SWIG_IsOK(res1)) {
51676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51677 }
51678 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51679 {
51680 PyThreadState* __tstate = wxPyBeginAllowThreads();
51681 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51682 wxPyEndAllowThreads(__tstate);
51683 if (PyErr_Occurred()) SWIG_fail;
51684 }
51685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51686 return resultobj;
51687 fail:
51688 return NULL;
51689 }
51690
51691
51692 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51693 PyObject *resultobj = 0;
51694 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51695 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51696 void *argp1 = 0 ;
51697 int res1 = 0 ;
51698 void *argp2 = 0 ;
51699 int res2 = 0 ;
51700 PyObject * obj0 = 0 ;
51701 PyObject * obj1 = 0 ;
51702 char * kwnames[] = {
51703 (char *) "self",(char *) "sizer", NULL
51704 };
51705
51706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51708 if (!SWIG_IsOK(res1)) {
51709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51710 }
51711 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51712 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51713 if (!SWIG_IsOK(res2)) {
51714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51715 }
51716 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51717 {
51718 PyThreadState* __tstate = wxPyBeginAllowThreads();
51719 (arg1)->SetGBSizer(arg2);
51720 wxPyEndAllowThreads(__tstate);
51721 if (PyErr_Occurred()) SWIG_fail;
51722 }
51723 resultobj = SWIG_Py_Void();
51724 return resultobj;
51725 fail:
51726 return NULL;
51727 }
51728
51729
51730 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51731 PyObject *obj;
51732 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51733 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51734 return SWIG_Py_Void();
51735 }
51736
51737 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51738 return SWIG_Python_InitShadowInstance(args);
51739 }
51740
51741 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51742 PyObject *resultobj = 0;
51743 int arg1 = (int) 0 ;
51744 int arg2 = (int) 0 ;
51745 wxGridBagSizer *result = 0 ;
51746 int val1 ;
51747 int ecode1 = 0 ;
51748 int val2 ;
51749 int ecode2 = 0 ;
51750 PyObject * obj0 = 0 ;
51751 PyObject * obj1 = 0 ;
51752 char * kwnames[] = {
51753 (char *) "vgap",(char *) "hgap", NULL
51754 };
51755
51756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51757 if (obj0) {
51758 ecode1 = SWIG_AsVal_int(obj0, &val1);
51759 if (!SWIG_IsOK(ecode1)) {
51760 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51761 }
51762 arg1 = static_cast< int >(val1);
51763 }
51764 if (obj1) {
51765 ecode2 = SWIG_AsVal_int(obj1, &val2);
51766 if (!SWIG_IsOK(ecode2)) {
51767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51768 }
51769 arg2 = static_cast< int >(val2);
51770 }
51771 {
51772 PyThreadState* __tstate = wxPyBeginAllowThreads();
51773 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51774 wxPyEndAllowThreads(__tstate);
51775 if (PyErr_Occurred()) SWIG_fail;
51776 }
51777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51778 return resultobj;
51779 fail:
51780 return NULL;
51781 }
51782
51783
51784 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51785 PyObject *resultobj = 0;
51786 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51787 PyObject *arg2 = (PyObject *) 0 ;
51788 wxGBPosition *arg3 = 0 ;
51789 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51790 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51791 int arg5 = (int) 0 ;
51792 int arg6 = (int) 0 ;
51793 PyObject *arg7 = (PyObject *) NULL ;
51794 wxGBSizerItem *result = 0 ;
51795 void *argp1 = 0 ;
51796 int res1 = 0 ;
51797 wxGBPosition temp3 ;
51798 wxGBSpan temp4 ;
51799 int val5 ;
51800 int ecode5 = 0 ;
51801 int val6 ;
51802 int ecode6 = 0 ;
51803 PyObject * obj0 = 0 ;
51804 PyObject * obj1 = 0 ;
51805 PyObject * obj2 = 0 ;
51806 PyObject * obj3 = 0 ;
51807 PyObject * obj4 = 0 ;
51808 PyObject * obj5 = 0 ;
51809 PyObject * obj6 = 0 ;
51810 char * kwnames[] = {
51811 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51812 };
51813
51814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51816 if (!SWIG_IsOK(res1)) {
51817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51818 }
51819 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51820 arg2 = obj1;
51821 {
51822 arg3 = &temp3;
51823 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51824 }
51825 if (obj3) {
51826 {
51827 arg4 = &temp4;
51828 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51829 }
51830 }
51831 if (obj4) {
51832 ecode5 = SWIG_AsVal_int(obj4, &val5);
51833 if (!SWIG_IsOK(ecode5)) {
51834 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51835 }
51836 arg5 = static_cast< int >(val5);
51837 }
51838 if (obj5) {
51839 ecode6 = SWIG_AsVal_int(obj5, &val6);
51840 if (!SWIG_IsOK(ecode6)) {
51841 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51842 }
51843 arg6 = static_cast< int >(val6);
51844 }
51845 if (obj6) {
51846 arg7 = obj6;
51847 }
51848 {
51849 PyThreadState* __tstate = wxPyBeginAllowThreads();
51850 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51851 wxPyEndAllowThreads(__tstate);
51852 if (PyErr_Occurred()) SWIG_fail;
51853 }
51854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51855 return resultobj;
51856 fail:
51857 return NULL;
51858 }
51859
51860
51861 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51862 PyObject *resultobj = 0;
51863 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51864 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51865 wxGBSizerItem *result = 0 ;
51866 void *argp1 = 0 ;
51867 int res1 = 0 ;
51868 int res2 = 0 ;
51869 PyObject * obj0 = 0 ;
51870 PyObject * obj1 = 0 ;
51871 char * kwnames[] = {
51872 (char *) "self",(char *) "item", NULL
51873 };
51874
51875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51877 if (!SWIG_IsOK(res1)) {
51878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51879 }
51880 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51881 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51882 if (!SWIG_IsOK(res2)) {
51883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51884 }
51885 {
51886 PyThreadState* __tstate = wxPyBeginAllowThreads();
51887 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51888 wxPyEndAllowThreads(__tstate);
51889 if (PyErr_Occurred()) SWIG_fail;
51890 }
51891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51892 return resultobj;
51893 fail:
51894 return NULL;
51895 }
51896
51897
51898 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51899 PyObject *resultobj = 0;
51900 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51901 int arg2 ;
51902 int arg3 ;
51903 wxSize result;
51904 void *argp1 = 0 ;
51905 int res1 = 0 ;
51906 int val2 ;
51907 int ecode2 = 0 ;
51908 int val3 ;
51909 int ecode3 = 0 ;
51910 PyObject * obj0 = 0 ;
51911 PyObject * obj1 = 0 ;
51912 PyObject * obj2 = 0 ;
51913 char * kwnames[] = {
51914 (char *) "self",(char *) "row",(char *) "col", NULL
51915 };
51916
51917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51919 if (!SWIG_IsOK(res1)) {
51920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51921 }
51922 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51923 ecode2 = SWIG_AsVal_int(obj1, &val2);
51924 if (!SWIG_IsOK(ecode2)) {
51925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51926 }
51927 arg2 = static_cast< int >(val2);
51928 ecode3 = SWIG_AsVal_int(obj2, &val3);
51929 if (!SWIG_IsOK(ecode3)) {
51930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51931 }
51932 arg3 = static_cast< int >(val3);
51933 {
51934 PyThreadState* __tstate = wxPyBeginAllowThreads();
51935 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51936 wxPyEndAllowThreads(__tstate);
51937 if (PyErr_Occurred()) SWIG_fail;
51938 }
51939 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51940 return resultobj;
51941 fail:
51942 return NULL;
51943 }
51944
51945
51946 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51947 PyObject *resultobj = 0;
51948 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51949 wxSize result;
51950 void *argp1 = 0 ;
51951 int res1 = 0 ;
51952 PyObject *swig_obj[1] ;
51953
51954 if (!args) SWIG_fail;
51955 swig_obj[0] = args;
51956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51957 if (!SWIG_IsOK(res1)) {
51958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51959 }
51960 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51961 {
51962 PyThreadState* __tstate = wxPyBeginAllowThreads();
51963 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51964 wxPyEndAllowThreads(__tstate);
51965 if (PyErr_Occurred()) SWIG_fail;
51966 }
51967 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51968 return resultobj;
51969 fail:
51970 return NULL;
51971 }
51972
51973
51974 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51975 PyObject *resultobj = 0;
51976 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51977 wxSize *arg2 = 0 ;
51978 void *argp1 = 0 ;
51979 int res1 = 0 ;
51980 wxSize temp2 ;
51981 PyObject * obj0 = 0 ;
51982 PyObject * obj1 = 0 ;
51983 char * kwnames[] = {
51984 (char *) "self",(char *) "sz", NULL
51985 };
51986
51987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51989 if (!SWIG_IsOK(res1)) {
51990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51991 }
51992 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51993 {
51994 arg2 = &temp2;
51995 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51996 }
51997 {
51998 PyThreadState* __tstate = wxPyBeginAllowThreads();
51999 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
52000 wxPyEndAllowThreads(__tstate);
52001 if (PyErr_Occurred()) SWIG_fail;
52002 }
52003 resultobj = SWIG_Py_Void();
52004 return resultobj;
52005 fail:
52006 return NULL;
52007 }
52008
52009
52010 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52011 PyObject *resultobj = 0;
52012 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52013 wxWindow *arg2 = (wxWindow *) 0 ;
52014 wxGBPosition result;
52015 void *argp1 = 0 ;
52016 int res1 = 0 ;
52017 void *argp2 = 0 ;
52018 int res2 = 0 ;
52019
52020 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52022 if (!SWIG_IsOK(res1)) {
52023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52024 }
52025 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52026 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52027 if (!SWIG_IsOK(res2)) {
52028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52029 }
52030 arg2 = reinterpret_cast< wxWindow * >(argp2);
52031 {
52032 PyThreadState* __tstate = wxPyBeginAllowThreads();
52033 result = (arg1)->GetItemPosition(arg2);
52034 wxPyEndAllowThreads(__tstate);
52035 if (PyErr_Occurred()) SWIG_fail;
52036 }
52037 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52038 return resultobj;
52039 fail:
52040 return NULL;
52041 }
52042
52043
52044 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52045 PyObject *resultobj = 0;
52046 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52047 wxSizer *arg2 = (wxSizer *) 0 ;
52048 wxGBPosition result;
52049 void *argp1 = 0 ;
52050 int res1 = 0 ;
52051 void *argp2 = 0 ;
52052 int res2 = 0 ;
52053
52054 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52056 if (!SWIG_IsOK(res1)) {
52057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52058 }
52059 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52060 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52061 if (!SWIG_IsOK(res2)) {
52062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52063 }
52064 arg2 = reinterpret_cast< wxSizer * >(argp2);
52065 {
52066 PyThreadState* __tstate = wxPyBeginAllowThreads();
52067 result = (arg1)->GetItemPosition(arg2);
52068 wxPyEndAllowThreads(__tstate);
52069 if (PyErr_Occurred()) SWIG_fail;
52070 }
52071 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52072 return resultobj;
52073 fail:
52074 return NULL;
52075 }
52076
52077
52078 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52079 PyObject *resultobj = 0;
52080 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52081 size_t arg2 ;
52082 wxGBPosition result;
52083 void *argp1 = 0 ;
52084 int res1 = 0 ;
52085 size_t val2 ;
52086 int ecode2 = 0 ;
52087
52088 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52090 if (!SWIG_IsOK(res1)) {
52091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52092 }
52093 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52094 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52095 if (!SWIG_IsOK(ecode2)) {
52096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52097 }
52098 arg2 = static_cast< size_t >(val2);
52099 {
52100 PyThreadState* __tstate = wxPyBeginAllowThreads();
52101 result = (arg1)->GetItemPosition(arg2);
52102 wxPyEndAllowThreads(__tstate);
52103 if (PyErr_Occurred()) SWIG_fail;
52104 }
52105 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52106 return resultobj;
52107 fail:
52108 return NULL;
52109 }
52110
52111
52112 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
52113 int argc;
52114 PyObject *argv[3];
52115
52116 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
52117 --argc;
52118 if (argc == 2) {
52119 int _v = 0;
52120 {
52121 void *vptr = 0;
52122 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52123 _v = SWIG_CheckState(res);
52124 }
52125 if (!_v) goto check_1;
52126 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
52127 }
52128 check_1:
52129
52130 if (argc == 2) {
52131 int _v = 0;
52132 {
52133 void *vptr = 0;
52134 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52135 _v = SWIG_CheckState(res);
52136 }
52137 if (!_v) goto check_2;
52138 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
52139 }
52140 check_2:
52141
52142 if (argc == 2) {
52143 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
52144 }
52145
52146 fail:
52147 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
52148 return NULL;
52149 }
52150
52151
52152 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52153 PyObject *resultobj = 0;
52154 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52155 wxWindow *arg2 = (wxWindow *) 0 ;
52156 wxGBPosition *arg3 = 0 ;
52157 bool result;
52158 void *argp1 = 0 ;
52159 int res1 = 0 ;
52160 void *argp2 = 0 ;
52161 int res2 = 0 ;
52162 wxGBPosition temp3 ;
52163
52164 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52166 if (!SWIG_IsOK(res1)) {
52167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52168 }
52169 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52170 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52171 if (!SWIG_IsOK(res2)) {
52172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52173 }
52174 arg2 = reinterpret_cast< wxWindow * >(argp2);
52175 {
52176 arg3 = &temp3;
52177 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52178 }
52179 {
52180 PyThreadState* __tstate = wxPyBeginAllowThreads();
52181 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52182 wxPyEndAllowThreads(__tstate);
52183 if (PyErr_Occurred()) SWIG_fail;
52184 }
52185 {
52186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52187 }
52188 return resultobj;
52189 fail:
52190 return NULL;
52191 }
52192
52193
52194 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52195 PyObject *resultobj = 0;
52196 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52197 wxSizer *arg2 = (wxSizer *) 0 ;
52198 wxGBPosition *arg3 = 0 ;
52199 bool result;
52200 void *argp1 = 0 ;
52201 int res1 = 0 ;
52202 void *argp2 = 0 ;
52203 int res2 = 0 ;
52204 wxGBPosition temp3 ;
52205
52206 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52208 if (!SWIG_IsOK(res1)) {
52209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52210 }
52211 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52212 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52213 if (!SWIG_IsOK(res2)) {
52214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52215 }
52216 arg2 = reinterpret_cast< wxSizer * >(argp2);
52217 {
52218 arg3 = &temp3;
52219 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52220 }
52221 {
52222 PyThreadState* __tstate = wxPyBeginAllowThreads();
52223 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52224 wxPyEndAllowThreads(__tstate);
52225 if (PyErr_Occurred()) SWIG_fail;
52226 }
52227 {
52228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52229 }
52230 return resultobj;
52231 fail:
52232 return NULL;
52233 }
52234
52235
52236 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52237 PyObject *resultobj = 0;
52238 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52239 size_t arg2 ;
52240 wxGBPosition *arg3 = 0 ;
52241 bool result;
52242 void *argp1 = 0 ;
52243 int res1 = 0 ;
52244 size_t val2 ;
52245 int ecode2 = 0 ;
52246 wxGBPosition temp3 ;
52247
52248 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52250 if (!SWIG_IsOK(res1)) {
52251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52252 }
52253 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52254 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52255 if (!SWIG_IsOK(ecode2)) {
52256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52257 }
52258 arg2 = static_cast< size_t >(val2);
52259 {
52260 arg3 = &temp3;
52261 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52262 }
52263 {
52264 PyThreadState* __tstate = wxPyBeginAllowThreads();
52265 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52266 wxPyEndAllowThreads(__tstate);
52267 if (PyErr_Occurred()) SWIG_fail;
52268 }
52269 {
52270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52271 }
52272 return resultobj;
52273 fail:
52274 return NULL;
52275 }
52276
52277
52278 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
52279 int argc;
52280 PyObject *argv[4];
52281
52282 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
52283 --argc;
52284 if (argc == 3) {
52285 int _v = 0;
52286 {
52287 void *vptr = 0;
52288 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52289 _v = SWIG_CheckState(res);
52290 }
52291 if (!_v) goto check_1;
52292 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
52293 }
52294 check_1:
52295
52296 if (argc == 3) {
52297 int _v = 0;
52298 {
52299 void *vptr = 0;
52300 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52301 _v = SWIG_CheckState(res);
52302 }
52303 if (!_v) goto check_2;
52304 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
52305 }
52306 check_2:
52307
52308 if (argc == 3) {
52309 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
52310 }
52311
52312 fail:
52313 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
52314 return NULL;
52315 }
52316
52317
52318 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52319 PyObject *resultobj = 0;
52320 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52321 wxWindow *arg2 = (wxWindow *) 0 ;
52322 wxGBSpan result;
52323 void *argp1 = 0 ;
52324 int res1 = 0 ;
52325 void *argp2 = 0 ;
52326 int res2 = 0 ;
52327
52328 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52330 if (!SWIG_IsOK(res1)) {
52331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52332 }
52333 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52334 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52335 if (!SWIG_IsOK(res2)) {
52336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52337 }
52338 arg2 = reinterpret_cast< wxWindow * >(argp2);
52339 {
52340 PyThreadState* __tstate = wxPyBeginAllowThreads();
52341 result = (arg1)->GetItemSpan(arg2);
52342 wxPyEndAllowThreads(__tstate);
52343 if (PyErr_Occurred()) SWIG_fail;
52344 }
52345 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52346 return resultobj;
52347 fail:
52348 return NULL;
52349 }
52350
52351
52352 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52353 PyObject *resultobj = 0;
52354 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52355 wxSizer *arg2 = (wxSizer *) 0 ;
52356 wxGBSpan result;
52357 void *argp1 = 0 ;
52358 int res1 = 0 ;
52359 void *argp2 = 0 ;
52360 int res2 = 0 ;
52361
52362 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52364 if (!SWIG_IsOK(res1)) {
52365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52366 }
52367 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52368 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52369 if (!SWIG_IsOK(res2)) {
52370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52371 }
52372 arg2 = reinterpret_cast< wxSizer * >(argp2);
52373 {
52374 PyThreadState* __tstate = wxPyBeginAllowThreads();
52375 result = (arg1)->GetItemSpan(arg2);
52376 wxPyEndAllowThreads(__tstate);
52377 if (PyErr_Occurred()) SWIG_fail;
52378 }
52379 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52380 return resultobj;
52381 fail:
52382 return NULL;
52383 }
52384
52385
52386 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52387 PyObject *resultobj = 0;
52388 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52389 size_t arg2 ;
52390 wxGBSpan result;
52391 void *argp1 = 0 ;
52392 int res1 = 0 ;
52393 size_t val2 ;
52394 int ecode2 = 0 ;
52395
52396 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52398 if (!SWIG_IsOK(res1)) {
52399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52400 }
52401 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52402 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52403 if (!SWIG_IsOK(ecode2)) {
52404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52405 }
52406 arg2 = static_cast< size_t >(val2);
52407 {
52408 PyThreadState* __tstate = wxPyBeginAllowThreads();
52409 result = (arg1)->GetItemSpan(arg2);
52410 wxPyEndAllowThreads(__tstate);
52411 if (PyErr_Occurred()) SWIG_fail;
52412 }
52413 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52414 return resultobj;
52415 fail:
52416 return NULL;
52417 }
52418
52419
52420 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
52421 int argc;
52422 PyObject *argv[3];
52423
52424 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
52425 --argc;
52426 if (argc == 2) {
52427 int _v = 0;
52428 {
52429 void *vptr = 0;
52430 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52431 _v = SWIG_CheckState(res);
52432 }
52433 if (!_v) goto check_1;
52434 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
52435 }
52436 check_1:
52437
52438 if (argc == 2) {
52439 int _v = 0;
52440 {
52441 void *vptr = 0;
52442 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52443 _v = SWIG_CheckState(res);
52444 }
52445 if (!_v) goto check_2;
52446 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
52447 }
52448 check_2:
52449
52450 if (argc == 2) {
52451 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
52452 }
52453
52454 fail:
52455 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
52456 return NULL;
52457 }
52458
52459
52460 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52461 PyObject *resultobj = 0;
52462 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52463 wxWindow *arg2 = (wxWindow *) 0 ;
52464 wxGBSpan *arg3 = 0 ;
52465 bool result;
52466 void *argp1 = 0 ;
52467 int res1 = 0 ;
52468 void *argp2 = 0 ;
52469 int res2 = 0 ;
52470 wxGBSpan temp3 ;
52471
52472 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52474 if (!SWIG_IsOK(res1)) {
52475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52476 }
52477 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52478 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52479 if (!SWIG_IsOK(res2)) {
52480 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52481 }
52482 arg2 = reinterpret_cast< wxWindow * >(argp2);
52483 {
52484 arg3 = &temp3;
52485 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52486 }
52487 {
52488 PyThreadState* __tstate = wxPyBeginAllowThreads();
52489 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52490 wxPyEndAllowThreads(__tstate);
52491 if (PyErr_Occurred()) SWIG_fail;
52492 }
52493 {
52494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52495 }
52496 return resultobj;
52497 fail:
52498 return NULL;
52499 }
52500
52501
52502 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52503 PyObject *resultobj = 0;
52504 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52505 wxSizer *arg2 = (wxSizer *) 0 ;
52506 wxGBSpan *arg3 = 0 ;
52507 bool result;
52508 void *argp1 = 0 ;
52509 int res1 = 0 ;
52510 void *argp2 = 0 ;
52511 int res2 = 0 ;
52512 wxGBSpan temp3 ;
52513
52514 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52516 if (!SWIG_IsOK(res1)) {
52517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52518 }
52519 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52520 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52521 if (!SWIG_IsOK(res2)) {
52522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52523 }
52524 arg2 = reinterpret_cast< wxSizer * >(argp2);
52525 {
52526 arg3 = &temp3;
52527 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52528 }
52529 {
52530 PyThreadState* __tstate = wxPyBeginAllowThreads();
52531 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52532 wxPyEndAllowThreads(__tstate);
52533 if (PyErr_Occurred()) SWIG_fail;
52534 }
52535 {
52536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52537 }
52538 return resultobj;
52539 fail:
52540 return NULL;
52541 }
52542
52543
52544 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52545 PyObject *resultobj = 0;
52546 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52547 size_t arg2 ;
52548 wxGBSpan *arg3 = 0 ;
52549 bool result;
52550 void *argp1 = 0 ;
52551 int res1 = 0 ;
52552 size_t val2 ;
52553 int ecode2 = 0 ;
52554 wxGBSpan temp3 ;
52555
52556 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52558 if (!SWIG_IsOK(res1)) {
52559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52560 }
52561 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52562 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52563 if (!SWIG_IsOK(ecode2)) {
52564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52565 }
52566 arg2 = static_cast< size_t >(val2);
52567 {
52568 arg3 = &temp3;
52569 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52570 }
52571 {
52572 PyThreadState* __tstate = wxPyBeginAllowThreads();
52573 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52574 wxPyEndAllowThreads(__tstate);
52575 if (PyErr_Occurred()) SWIG_fail;
52576 }
52577 {
52578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52579 }
52580 return resultobj;
52581 fail:
52582 return NULL;
52583 }
52584
52585
52586 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52587 int argc;
52588 PyObject *argv[4];
52589
52590 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52591 --argc;
52592 if (argc == 3) {
52593 int _v = 0;
52594 {
52595 void *vptr = 0;
52596 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52597 _v = SWIG_CheckState(res);
52598 }
52599 if (!_v) goto check_1;
52600 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52601 }
52602 check_1:
52603
52604 if (argc == 3) {
52605 int _v = 0;
52606 {
52607 void *vptr = 0;
52608 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52609 _v = SWIG_CheckState(res);
52610 }
52611 if (!_v) goto check_2;
52612 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52613 }
52614 check_2:
52615
52616 if (argc == 3) {
52617 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52618 }
52619
52620 fail:
52621 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52622 return NULL;
52623 }
52624
52625
52626 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52627 PyObject *resultobj = 0;
52628 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52629 wxWindow *arg2 = (wxWindow *) 0 ;
52630 wxGBSizerItem *result = 0 ;
52631 void *argp1 = 0 ;
52632 int res1 = 0 ;
52633 void *argp2 = 0 ;
52634 int res2 = 0 ;
52635
52636 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52638 if (!SWIG_IsOK(res1)) {
52639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52640 }
52641 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52642 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52643 if (!SWIG_IsOK(res2)) {
52644 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52645 }
52646 arg2 = reinterpret_cast< wxWindow * >(argp2);
52647 {
52648 PyThreadState* __tstate = wxPyBeginAllowThreads();
52649 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52650 wxPyEndAllowThreads(__tstate);
52651 if (PyErr_Occurred()) SWIG_fail;
52652 }
52653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52654 return resultobj;
52655 fail:
52656 return NULL;
52657 }
52658
52659
52660 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52661 PyObject *resultobj = 0;
52662 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52663 wxSizer *arg2 = (wxSizer *) 0 ;
52664 wxGBSizerItem *result = 0 ;
52665 void *argp1 = 0 ;
52666 int res1 = 0 ;
52667 void *argp2 = 0 ;
52668 int res2 = 0 ;
52669
52670 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52672 if (!SWIG_IsOK(res1)) {
52673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52674 }
52675 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52676 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52677 if (!SWIG_IsOK(res2)) {
52678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52679 }
52680 arg2 = reinterpret_cast< wxSizer * >(argp2);
52681 {
52682 PyThreadState* __tstate = wxPyBeginAllowThreads();
52683 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52684 wxPyEndAllowThreads(__tstate);
52685 if (PyErr_Occurred()) SWIG_fail;
52686 }
52687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52688 return resultobj;
52689 fail:
52690 return NULL;
52691 }
52692
52693
52694 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52695 int argc;
52696 PyObject *argv[3];
52697
52698 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52699 --argc;
52700 if (argc == 2) {
52701 int _v = 0;
52702 {
52703 void *vptr = 0;
52704 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52705 _v = SWIG_CheckState(res);
52706 }
52707 if (!_v) goto check_1;
52708 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52709 }
52710 check_1:
52711
52712 if (argc == 2) {
52713 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52714 }
52715
52716 fail:
52717 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52718 return NULL;
52719 }
52720
52721
52722 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52723 PyObject *resultobj = 0;
52724 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52725 wxGBPosition *arg2 = 0 ;
52726 wxGBSizerItem *result = 0 ;
52727 void *argp1 = 0 ;
52728 int res1 = 0 ;
52729 wxGBPosition temp2 ;
52730 PyObject * obj0 = 0 ;
52731 PyObject * obj1 = 0 ;
52732 char * kwnames[] = {
52733 (char *) "self",(char *) "pos", NULL
52734 };
52735
52736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52738 if (!SWIG_IsOK(res1)) {
52739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52740 }
52741 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52742 {
52743 arg2 = &temp2;
52744 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52745 }
52746 {
52747 PyThreadState* __tstate = wxPyBeginAllowThreads();
52748 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52749 wxPyEndAllowThreads(__tstate);
52750 if (PyErr_Occurred()) SWIG_fail;
52751 }
52752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52753 return resultobj;
52754 fail:
52755 return NULL;
52756 }
52757
52758
52759 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52760 PyObject *resultobj = 0;
52761 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52762 wxPoint *arg2 = 0 ;
52763 wxGBSizerItem *result = 0 ;
52764 void *argp1 = 0 ;
52765 int res1 = 0 ;
52766 wxPoint temp2 ;
52767 PyObject * obj0 = 0 ;
52768 PyObject * obj1 = 0 ;
52769 char * kwnames[] = {
52770 (char *) "self",(char *) "pt", NULL
52771 };
52772
52773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52775 if (!SWIG_IsOK(res1)) {
52776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52777 }
52778 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52779 {
52780 arg2 = &temp2;
52781 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52782 }
52783 {
52784 PyThreadState* __tstate = wxPyBeginAllowThreads();
52785 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52786 wxPyEndAllowThreads(__tstate);
52787 if (PyErr_Occurred()) SWIG_fail;
52788 }
52789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52790 return resultobj;
52791 fail:
52792 return NULL;
52793 }
52794
52795
52796 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52797 PyObject *resultobj = 0;
52798 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52799 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52800 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52801 bool result;
52802 void *argp1 = 0 ;
52803 int res1 = 0 ;
52804 void *argp2 = 0 ;
52805 int res2 = 0 ;
52806 void *argp3 = 0 ;
52807 int res3 = 0 ;
52808 PyObject * obj0 = 0 ;
52809 PyObject * obj1 = 0 ;
52810 PyObject * obj2 = 0 ;
52811 char * kwnames[] = {
52812 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52813 };
52814
52815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52817 if (!SWIG_IsOK(res1)) {
52818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52819 }
52820 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52821 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52822 if (!SWIG_IsOK(res2)) {
52823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52824 }
52825 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52826 if (obj2) {
52827 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52828 if (!SWIG_IsOK(res3)) {
52829 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52830 }
52831 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52832 }
52833 {
52834 PyThreadState* __tstate = wxPyBeginAllowThreads();
52835 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52836 wxPyEndAllowThreads(__tstate);
52837 if (PyErr_Occurred()) SWIG_fail;
52838 }
52839 {
52840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52841 }
52842 return resultobj;
52843 fail:
52844 return NULL;
52845 }
52846
52847
52848 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52849 PyObject *resultobj = 0;
52850 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52851 wxGBPosition *arg2 = 0 ;
52852 wxGBSpan *arg3 = 0 ;
52853 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52854 bool result;
52855 void *argp1 = 0 ;
52856 int res1 = 0 ;
52857 wxGBPosition temp2 ;
52858 wxGBSpan temp3 ;
52859 void *argp4 = 0 ;
52860 int res4 = 0 ;
52861 PyObject * obj0 = 0 ;
52862 PyObject * obj1 = 0 ;
52863 PyObject * obj2 = 0 ;
52864 PyObject * obj3 = 0 ;
52865 char * kwnames[] = {
52866 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52867 };
52868
52869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52871 if (!SWIG_IsOK(res1)) {
52872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52873 }
52874 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52875 {
52876 arg2 = &temp2;
52877 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52878 }
52879 {
52880 arg3 = &temp3;
52881 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52882 }
52883 if (obj3) {
52884 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52885 if (!SWIG_IsOK(res4)) {
52886 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52887 }
52888 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52889 }
52890 {
52891 PyThreadState* __tstate = wxPyBeginAllowThreads();
52892 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52893 wxPyEndAllowThreads(__tstate);
52894 if (PyErr_Occurred()) SWIG_fail;
52895 }
52896 {
52897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52898 }
52899 return resultobj;
52900 fail:
52901 return NULL;
52902 }
52903
52904
52905 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52906 PyObject *obj;
52907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52908 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52909 return SWIG_Py_Void();
52910 }
52911
52912 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52913 return SWIG_Python_InitShadowInstance(args);
52914 }
52915
52916 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52917 PyObject *resultobj = 0;
52918 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52919 wxRelationship arg2 ;
52920 wxWindow *arg3 = (wxWindow *) 0 ;
52921 wxEdge arg4 ;
52922 int arg5 = (int) 0 ;
52923 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52924 void *argp1 = 0 ;
52925 int res1 = 0 ;
52926 int val2 ;
52927 int ecode2 = 0 ;
52928 void *argp3 = 0 ;
52929 int res3 = 0 ;
52930 int val4 ;
52931 int ecode4 = 0 ;
52932 int val5 ;
52933 int ecode5 = 0 ;
52934 int val6 ;
52935 int ecode6 = 0 ;
52936 PyObject * obj0 = 0 ;
52937 PyObject * obj1 = 0 ;
52938 PyObject * obj2 = 0 ;
52939 PyObject * obj3 = 0 ;
52940 PyObject * obj4 = 0 ;
52941 PyObject * obj5 = 0 ;
52942 char * kwnames[] = {
52943 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52944 };
52945
52946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52948 if (!SWIG_IsOK(res1)) {
52949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52950 }
52951 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52952 ecode2 = SWIG_AsVal_int(obj1, &val2);
52953 if (!SWIG_IsOK(ecode2)) {
52954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52955 }
52956 arg2 = static_cast< wxRelationship >(val2);
52957 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52958 if (!SWIG_IsOK(res3)) {
52959 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52960 }
52961 arg3 = reinterpret_cast< wxWindow * >(argp3);
52962 ecode4 = SWIG_AsVal_int(obj3, &val4);
52963 if (!SWIG_IsOK(ecode4)) {
52964 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52965 }
52966 arg4 = static_cast< wxEdge >(val4);
52967 if (obj4) {
52968 ecode5 = SWIG_AsVal_int(obj4, &val5);
52969 if (!SWIG_IsOK(ecode5)) {
52970 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52971 }
52972 arg5 = static_cast< int >(val5);
52973 }
52974 if (obj5) {
52975 ecode6 = SWIG_AsVal_int(obj5, &val6);
52976 if (!SWIG_IsOK(ecode6)) {
52977 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52978 }
52979 arg6 = static_cast< int >(val6);
52980 }
52981 {
52982 PyThreadState* __tstate = wxPyBeginAllowThreads();
52983 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52984 wxPyEndAllowThreads(__tstate);
52985 if (PyErr_Occurred()) SWIG_fail;
52986 }
52987 resultobj = SWIG_Py_Void();
52988 return resultobj;
52989 fail:
52990 return NULL;
52991 }
52992
52993
52994 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52995 PyObject *resultobj = 0;
52996 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52997 wxWindow *arg2 = (wxWindow *) 0 ;
52998 int arg3 = (int) 0 ;
52999 void *argp1 = 0 ;
53000 int res1 = 0 ;
53001 void *argp2 = 0 ;
53002 int res2 = 0 ;
53003 int val3 ;
53004 int ecode3 = 0 ;
53005 PyObject * obj0 = 0 ;
53006 PyObject * obj1 = 0 ;
53007 PyObject * obj2 = 0 ;
53008 char * kwnames[] = {
53009 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53010 };
53011
53012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53014 if (!SWIG_IsOK(res1)) {
53015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53016 }
53017 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53018 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53019 if (!SWIG_IsOK(res2)) {
53020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53021 }
53022 arg2 = reinterpret_cast< wxWindow * >(argp2);
53023 if (obj2) {
53024 ecode3 = SWIG_AsVal_int(obj2, &val3);
53025 if (!SWIG_IsOK(ecode3)) {
53026 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
53027 }
53028 arg3 = static_cast< int >(val3);
53029 }
53030 {
53031 PyThreadState* __tstate = wxPyBeginAllowThreads();
53032 (arg1)->LeftOf(arg2,arg3);
53033 wxPyEndAllowThreads(__tstate);
53034 if (PyErr_Occurred()) SWIG_fail;
53035 }
53036 resultobj = SWIG_Py_Void();
53037 return resultobj;
53038 fail:
53039 return NULL;
53040 }
53041
53042
53043 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53044 PyObject *resultobj = 0;
53045 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53046 wxWindow *arg2 = (wxWindow *) 0 ;
53047 int arg3 = (int) 0 ;
53048 void *argp1 = 0 ;
53049 int res1 = 0 ;
53050 void *argp2 = 0 ;
53051 int res2 = 0 ;
53052 int val3 ;
53053 int ecode3 = 0 ;
53054 PyObject * obj0 = 0 ;
53055 PyObject * obj1 = 0 ;
53056 PyObject * obj2 = 0 ;
53057 char * kwnames[] = {
53058 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53059 };
53060
53061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53063 if (!SWIG_IsOK(res1)) {
53064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53065 }
53066 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53067 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53068 if (!SWIG_IsOK(res2)) {
53069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53070 }
53071 arg2 = reinterpret_cast< wxWindow * >(argp2);
53072 if (obj2) {
53073 ecode3 = SWIG_AsVal_int(obj2, &val3);
53074 if (!SWIG_IsOK(ecode3)) {
53075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
53076 }
53077 arg3 = static_cast< int >(val3);
53078 }
53079 {
53080 PyThreadState* __tstate = wxPyBeginAllowThreads();
53081 (arg1)->RightOf(arg2,arg3);
53082 wxPyEndAllowThreads(__tstate);
53083 if (PyErr_Occurred()) SWIG_fail;
53084 }
53085 resultobj = SWIG_Py_Void();
53086 return resultobj;
53087 fail:
53088 return NULL;
53089 }
53090
53091
53092 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53093 PyObject *resultobj = 0;
53094 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53095 wxWindow *arg2 = (wxWindow *) 0 ;
53096 int arg3 = (int) 0 ;
53097 void *argp1 = 0 ;
53098 int res1 = 0 ;
53099 void *argp2 = 0 ;
53100 int res2 = 0 ;
53101 int val3 ;
53102 int ecode3 = 0 ;
53103 PyObject * obj0 = 0 ;
53104 PyObject * obj1 = 0 ;
53105 PyObject * obj2 = 0 ;
53106 char * kwnames[] = {
53107 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53108 };
53109
53110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53112 if (!SWIG_IsOK(res1)) {
53113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53114 }
53115 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53116 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53117 if (!SWIG_IsOK(res2)) {
53118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
53119 }
53120 arg2 = reinterpret_cast< wxWindow * >(argp2);
53121 if (obj2) {
53122 ecode3 = SWIG_AsVal_int(obj2, &val3);
53123 if (!SWIG_IsOK(ecode3)) {
53124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
53125 }
53126 arg3 = static_cast< int >(val3);
53127 }
53128 {
53129 PyThreadState* __tstate = wxPyBeginAllowThreads();
53130 (arg1)->Above(arg2,arg3);
53131 wxPyEndAllowThreads(__tstate);
53132 if (PyErr_Occurred()) SWIG_fail;
53133 }
53134 resultobj = SWIG_Py_Void();
53135 return resultobj;
53136 fail:
53137 return NULL;
53138 }
53139
53140
53141 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53142 PyObject *resultobj = 0;
53143 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53144 wxWindow *arg2 = (wxWindow *) 0 ;
53145 int arg3 = (int) 0 ;
53146 void *argp1 = 0 ;
53147 int res1 = 0 ;
53148 void *argp2 = 0 ;
53149 int res2 = 0 ;
53150 int val3 ;
53151 int ecode3 = 0 ;
53152 PyObject * obj0 = 0 ;
53153 PyObject * obj1 = 0 ;
53154 PyObject * obj2 = 0 ;
53155 char * kwnames[] = {
53156 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53157 };
53158
53159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53161 if (!SWIG_IsOK(res1)) {
53162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53163 }
53164 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53165 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53166 if (!SWIG_IsOK(res2)) {
53167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
53168 }
53169 arg2 = reinterpret_cast< wxWindow * >(argp2);
53170 if (obj2) {
53171 ecode3 = SWIG_AsVal_int(obj2, &val3);
53172 if (!SWIG_IsOK(ecode3)) {
53173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
53174 }
53175 arg3 = static_cast< int >(val3);
53176 }
53177 {
53178 PyThreadState* __tstate = wxPyBeginAllowThreads();
53179 (arg1)->Below(arg2,arg3);
53180 wxPyEndAllowThreads(__tstate);
53181 if (PyErr_Occurred()) SWIG_fail;
53182 }
53183 resultobj = SWIG_Py_Void();
53184 return resultobj;
53185 fail:
53186 return NULL;
53187 }
53188
53189
53190 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53191 PyObject *resultobj = 0;
53192 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53193 wxWindow *arg2 = (wxWindow *) 0 ;
53194 wxEdge arg3 ;
53195 int arg4 = (int) 0 ;
53196 void *argp1 = 0 ;
53197 int res1 = 0 ;
53198 void *argp2 = 0 ;
53199 int res2 = 0 ;
53200 int val3 ;
53201 int ecode3 = 0 ;
53202 int val4 ;
53203 int ecode4 = 0 ;
53204 PyObject * obj0 = 0 ;
53205 PyObject * obj1 = 0 ;
53206 PyObject * obj2 = 0 ;
53207 PyObject * obj3 = 0 ;
53208 char * kwnames[] = {
53209 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
53210 };
53211
53212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53214 if (!SWIG_IsOK(res1)) {
53215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53216 }
53217 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53219 if (!SWIG_IsOK(res2)) {
53220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
53221 }
53222 arg2 = reinterpret_cast< wxWindow * >(argp2);
53223 ecode3 = SWIG_AsVal_int(obj2, &val3);
53224 if (!SWIG_IsOK(ecode3)) {
53225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
53226 }
53227 arg3 = static_cast< wxEdge >(val3);
53228 if (obj3) {
53229 ecode4 = SWIG_AsVal_int(obj3, &val4);
53230 if (!SWIG_IsOK(ecode4)) {
53231 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
53232 }
53233 arg4 = static_cast< int >(val4);
53234 }
53235 {
53236 PyThreadState* __tstate = wxPyBeginAllowThreads();
53237 (arg1)->SameAs(arg2,arg3,arg4);
53238 wxPyEndAllowThreads(__tstate);
53239 if (PyErr_Occurred()) SWIG_fail;
53240 }
53241 resultobj = SWIG_Py_Void();
53242 return resultobj;
53243 fail:
53244 return NULL;
53245 }
53246
53247
53248 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53249 PyObject *resultobj = 0;
53250 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53251 wxWindow *arg2 = (wxWindow *) 0 ;
53252 wxEdge arg3 ;
53253 int arg4 ;
53254 void *argp1 = 0 ;
53255 int res1 = 0 ;
53256 void *argp2 = 0 ;
53257 int res2 = 0 ;
53258 int val3 ;
53259 int ecode3 = 0 ;
53260 int val4 ;
53261 int ecode4 = 0 ;
53262 PyObject * obj0 = 0 ;
53263 PyObject * obj1 = 0 ;
53264 PyObject * obj2 = 0 ;
53265 PyObject * obj3 = 0 ;
53266 char * kwnames[] = {
53267 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
53268 };
53269
53270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53272 if (!SWIG_IsOK(res1)) {
53273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53274 }
53275 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53276 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53277 if (!SWIG_IsOK(res2)) {
53278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53279 }
53280 arg2 = reinterpret_cast< wxWindow * >(argp2);
53281 ecode3 = SWIG_AsVal_int(obj2, &val3);
53282 if (!SWIG_IsOK(ecode3)) {
53283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
53284 }
53285 arg3 = static_cast< wxEdge >(val3);
53286 ecode4 = SWIG_AsVal_int(obj3, &val4);
53287 if (!SWIG_IsOK(ecode4)) {
53288 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
53289 }
53290 arg4 = static_cast< int >(val4);
53291 {
53292 PyThreadState* __tstate = wxPyBeginAllowThreads();
53293 (arg1)->PercentOf(arg2,arg3,arg4);
53294 wxPyEndAllowThreads(__tstate);
53295 if (PyErr_Occurred()) SWIG_fail;
53296 }
53297 resultobj = SWIG_Py_Void();
53298 return resultobj;
53299 fail:
53300 return NULL;
53301 }
53302
53303
53304 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53305 PyObject *resultobj = 0;
53306 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53307 int arg2 ;
53308 void *argp1 = 0 ;
53309 int res1 = 0 ;
53310 int val2 ;
53311 int ecode2 = 0 ;
53312 PyObject * obj0 = 0 ;
53313 PyObject * obj1 = 0 ;
53314 char * kwnames[] = {
53315 (char *) "self",(char *) "val", NULL
53316 };
53317
53318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
53319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53320 if (!SWIG_IsOK(res1)) {
53321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53322 }
53323 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53324 ecode2 = SWIG_AsVal_int(obj1, &val2);
53325 if (!SWIG_IsOK(ecode2)) {
53326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
53327 }
53328 arg2 = static_cast< int >(val2);
53329 {
53330 PyThreadState* __tstate = wxPyBeginAllowThreads();
53331 (arg1)->Absolute(arg2);
53332 wxPyEndAllowThreads(__tstate);
53333 if (PyErr_Occurred()) SWIG_fail;
53334 }
53335 resultobj = SWIG_Py_Void();
53336 return resultobj;
53337 fail:
53338 return NULL;
53339 }
53340
53341
53342 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53343 PyObject *resultobj = 0;
53344 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53345 void *argp1 = 0 ;
53346 int res1 = 0 ;
53347 PyObject *swig_obj[1] ;
53348
53349 if (!args) SWIG_fail;
53350 swig_obj[0] = args;
53351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53352 if (!SWIG_IsOK(res1)) {
53353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53354 }
53355 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53356 {
53357 PyThreadState* __tstate = wxPyBeginAllowThreads();
53358 (arg1)->Unconstrained();
53359 wxPyEndAllowThreads(__tstate);
53360 if (PyErr_Occurred()) SWIG_fail;
53361 }
53362 resultobj = SWIG_Py_Void();
53363 return resultobj;
53364 fail:
53365 return NULL;
53366 }
53367
53368
53369 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53370 PyObject *resultobj = 0;
53371 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53372 void *argp1 = 0 ;
53373 int res1 = 0 ;
53374 PyObject *swig_obj[1] ;
53375
53376 if (!args) SWIG_fail;
53377 swig_obj[0] = args;
53378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53379 if (!SWIG_IsOK(res1)) {
53380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53381 }
53382 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53383 {
53384 PyThreadState* __tstate = wxPyBeginAllowThreads();
53385 (arg1)->AsIs();
53386 wxPyEndAllowThreads(__tstate);
53387 if (PyErr_Occurred()) SWIG_fail;
53388 }
53389 resultobj = SWIG_Py_Void();
53390 return resultobj;
53391 fail:
53392 return NULL;
53393 }
53394
53395
53396 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53397 PyObject *resultobj = 0;
53398 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53399 wxWindow *result = 0 ;
53400 void *argp1 = 0 ;
53401 int res1 = 0 ;
53402 PyObject *swig_obj[1] ;
53403
53404 if (!args) SWIG_fail;
53405 swig_obj[0] = args;
53406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53407 if (!SWIG_IsOK(res1)) {
53408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53409 }
53410 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53411 {
53412 PyThreadState* __tstate = wxPyBeginAllowThreads();
53413 result = (wxWindow *)(arg1)->GetOtherWindow();
53414 wxPyEndAllowThreads(__tstate);
53415 if (PyErr_Occurred()) SWIG_fail;
53416 }
53417 {
53418 resultobj = wxPyMake_wxObject(result, 0);
53419 }
53420 return resultobj;
53421 fail:
53422 return NULL;
53423 }
53424
53425
53426 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53427 PyObject *resultobj = 0;
53428 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53429 wxEdge result;
53430 void *argp1 = 0 ;
53431 int res1 = 0 ;
53432 PyObject *swig_obj[1] ;
53433
53434 if (!args) SWIG_fail;
53435 swig_obj[0] = args;
53436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53437 if (!SWIG_IsOK(res1)) {
53438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53439 }
53440 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53441 {
53442 PyThreadState* __tstate = wxPyBeginAllowThreads();
53443 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
53444 wxPyEndAllowThreads(__tstate);
53445 if (PyErr_Occurred()) SWIG_fail;
53446 }
53447 resultobj = SWIG_From_int(static_cast< int >(result));
53448 return resultobj;
53449 fail:
53450 return NULL;
53451 }
53452
53453
53454 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53455 PyObject *resultobj = 0;
53456 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53457 wxEdge arg2 ;
53458 void *argp1 = 0 ;
53459 int res1 = 0 ;
53460 int val2 ;
53461 int ecode2 = 0 ;
53462 PyObject * obj0 = 0 ;
53463 PyObject * obj1 = 0 ;
53464 char * kwnames[] = {
53465 (char *) "self",(char *) "which", NULL
53466 };
53467
53468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
53469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53470 if (!SWIG_IsOK(res1)) {
53471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53472 }
53473 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53474 ecode2 = SWIG_AsVal_int(obj1, &val2);
53475 if (!SWIG_IsOK(ecode2)) {
53476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53477 }
53478 arg2 = static_cast< wxEdge >(val2);
53479 {
53480 PyThreadState* __tstate = wxPyBeginAllowThreads();
53481 (arg1)->SetEdge(arg2);
53482 wxPyEndAllowThreads(__tstate);
53483 if (PyErr_Occurred()) SWIG_fail;
53484 }
53485 resultobj = SWIG_Py_Void();
53486 return resultobj;
53487 fail:
53488 return NULL;
53489 }
53490
53491
53492 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53493 PyObject *resultobj = 0;
53494 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53495 int arg2 ;
53496 void *argp1 = 0 ;
53497 int res1 = 0 ;
53498 int val2 ;
53499 int ecode2 = 0 ;
53500 PyObject * obj0 = 0 ;
53501 PyObject * obj1 = 0 ;
53502 char * kwnames[] = {
53503 (char *) "self",(char *) "v", NULL
53504 };
53505
53506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
53507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53508 if (!SWIG_IsOK(res1)) {
53509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53510 }
53511 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53512 ecode2 = SWIG_AsVal_int(obj1, &val2);
53513 if (!SWIG_IsOK(ecode2)) {
53514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
53515 }
53516 arg2 = static_cast< int >(val2);
53517 {
53518 PyThreadState* __tstate = wxPyBeginAllowThreads();
53519 (arg1)->SetValue(arg2);
53520 wxPyEndAllowThreads(__tstate);
53521 if (PyErr_Occurred()) SWIG_fail;
53522 }
53523 resultobj = SWIG_Py_Void();
53524 return resultobj;
53525 fail:
53526 return NULL;
53527 }
53528
53529
53530 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53531 PyObject *resultobj = 0;
53532 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53533 int result;
53534 void *argp1 = 0 ;
53535 int res1 = 0 ;
53536 PyObject *swig_obj[1] ;
53537
53538 if (!args) SWIG_fail;
53539 swig_obj[0] = args;
53540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53541 if (!SWIG_IsOK(res1)) {
53542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53543 }
53544 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53545 {
53546 PyThreadState* __tstate = wxPyBeginAllowThreads();
53547 result = (int)(arg1)->GetMargin();
53548 wxPyEndAllowThreads(__tstate);
53549 if (PyErr_Occurred()) SWIG_fail;
53550 }
53551 resultobj = SWIG_From_int(static_cast< int >(result));
53552 return resultobj;
53553 fail:
53554 return NULL;
53555 }
53556
53557
53558 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53559 PyObject *resultobj = 0;
53560 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53561 int arg2 ;
53562 void *argp1 = 0 ;
53563 int res1 = 0 ;
53564 int val2 ;
53565 int ecode2 = 0 ;
53566 PyObject * obj0 = 0 ;
53567 PyObject * obj1 = 0 ;
53568 char * kwnames[] = {
53569 (char *) "self",(char *) "m", NULL
53570 };
53571
53572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53574 if (!SWIG_IsOK(res1)) {
53575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53576 }
53577 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53578 ecode2 = SWIG_AsVal_int(obj1, &val2);
53579 if (!SWIG_IsOK(ecode2)) {
53580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53581 }
53582 arg2 = static_cast< int >(val2);
53583 {
53584 PyThreadState* __tstate = wxPyBeginAllowThreads();
53585 (arg1)->SetMargin(arg2);
53586 wxPyEndAllowThreads(__tstate);
53587 if (PyErr_Occurred()) SWIG_fail;
53588 }
53589 resultobj = SWIG_Py_Void();
53590 return resultobj;
53591 fail:
53592 return NULL;
53593 }
53594
53595
53596 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53597 PyObject *resultobj = 0;
53598 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53599 int result;
53600 void *argp1 = 0 ;
53601 int res1 = 0 ;
53602 PyObject *swig_obj[1] ;
53603
53604 if (!args) SWIG_fail;
53605 swig_obj[0] = args;
53606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53607 if (!SWIG_IsOK(res1)) {
53608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53609 }
53610 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53611 {
53612 PyThreadState* __tstate = wxPyBeginAllowThreads();
53613 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53614 wxPyEndAllowThreads(__tstate);
53615 if (PyErr_Occurred()) SWIG_fail;
53616 }
53617 resultobj = SWIG_From_int(static_cast< int >(result));
53618 return resultobj;
53619 fail:
53620 return NULL;
53621 }
53622
53623
53624 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53625 PyObject *resultobj = 0;
53626 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53627 int result;
53628 void *argp1 = 0 ;
53629 int res1 = 0 ;
53630 PyObject *swig_obj[1] ;
53631
53632 if (!args) SWIG_fail;
53633 swig_obj[0] = args;
53634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53635 if (!SWIG_IsOK(res1)) {
53636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53637 }
53638 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53639 {
53640 PyThreadState* __tstate = wxPyBeginAllowThreads();
53641 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53642 wxPyEndAllowThreads(__tstate);
53643 if (PyErr_Occurred()) SWIG_fail;
53644 }
53645 resultobj = SWIG_From_int(static_cast< int >(result));
53646 return resultobj;
53647 fail:
53648 return NULL;
53649 }
53650
53651
53652 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53653 PyObject *resultobj = 0;
53654 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53655 int result;
53656 void *argp1 = 0 ;
53657 int res1 = 0 ;
53658 PyObject *swig_obj[1] ;
53659
53660 if (!args) SWIG_fail;
53661 swig_obj[0] = args;
53662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53663 if (!SWIG_IsOK(res1)) {
53664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53665 }
53666 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53667 {
53668 PyThreadState* __tstate = wxPyBeginAllowThreads();
53669 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53670 wxPyEndAllowThreads(__tstate);
53671 if (PyErr_Occurred()) SWIG_fail;
53672 }
53673 resultobj = SWIG_From_int(static_cast< int >(result));
53674 return resultobj;
53675 fail:
53676 return NULL;
53677 }
53678
53679
53680 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53681 PyObject *resultobj = 0;
53682 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53683 bool result;
53684 void *argp1 = 0 ;
53685 int res1 = 0 ;
53686 PyObject *swig_obj[1] ;
53687
53688 if (!args) SWIG_fail;
53689 swig_obj[0] = args;
53690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53691 if (!SWIG_IsOK(res1)) {
53692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53693 }
53694 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53695 {
53696 PyThreadState* __tstate = wxPyBeginAllowThreads();
53697 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53698 wxPyEndAllowThreads(__tstate);
53699 if (PyErr_Occurred()) SWIG_fail;
53700 }
53701 {
53702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53703 }
53704 return resultobj;
53705 fail:
53706 return NULL;
53707 }
53708
53709
53710 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53711 PyObject *resultobj = 0;
53712 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53713 bool arg2 ;
53714 void *argp1 = 0 ;
53715 int res1 = 0 ;
53716 bool val2 ;
53717 int ecode2 = 0 ;
53718 PyObject * obj0 = 0 ;
53719 PyObject * obj1 = 0 ;
53720 char * kwnames[] = {
53721 (char *) "self",(char *) "d", NULL
53722 };
53723
53724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53726 if (!SWIG_IsOK(res1)) {
53727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53728 }
53729 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53730 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53731 if (!SWIG_IsOK(ecode2)) {
53732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53733 }
53734 arg2 = static_cast< bool >(val2);
53735 {
53736 PyThreadState* __tstate = wxPyBeginAllowThreads();
53737 (arg1)->SetDone(arg2);
53738 wxPyEndAllowThreads(__tstate);
53739 if (PyErr_Occurred()) SWIG_fail;
53740 }
53741 resultobj = SWIG_Py_Void();
53742 return resultobj;
53743 fail:
53744 return NULL;
53745 }
53746
53747
53748 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53749 PyObject *resultobj = 0;
53750 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53751 wxRelationship result;
53752 void *argp1 = 0 ;
53753 int res1 = 0 ;
53754 PyObject *swig_obj[1] ;
53755
53756 if (!args) SWIG_fail;
53757 swig_obj[0] = args;
53758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53759 if (!SWIG_IsOK(res1)) {
53760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53761 }
53762 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53763 {
53764 PyThreadState* __tstate = wxPyBeginAllowThreads();
53765 result = (wxRelationship)(arg1)->GetRelationship();
53766 wxPyEndAllowThreads(__tstate);
53767 if (PyErr_Occurred()) SWIG_fail;
53768 }
53769 resultobj = SWIG_From_int(static_cast< int >(result));
53770 return resultobj;
53771 fail:
53772 return NULL;
53773 }
53774
53775
53776 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53777 PyObject *resultobj = 0;
53778 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53779 wxRelationship arg2 ;
53780 void *argp1 = 0 ;
53781 int res1 = 0 ;
53782 int val2 ;
53783 int ecode2 = 0 ;
53784 PyObject * obj0 = 0 ;
53785 PyObject * obj1 = 0 ;
53786 char * kwnames[] = {
53787 (char *) "self",(char *) "r", NULL
53788 };
53789
53790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53792 if (!SWIG_IsOK(res1)) {
53793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53794 }
53795 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53796 ecode2 = SWIG_AsVal_int(obj1, &val2);
53797 if (!SWIG_IsOK(ecode2)) {
53798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53799 }
53800 arg2 = static_cast< wxRelationship >(val2);
53801 {
53802 PyThreadState* __tstate = wxPyBeginAllowThreads();
53803 (arg1)->SetRelationship(arg2);
53804 wxPyEndAllowThreads(__tstate);
53805 if (PyErr_Occurred()) SWIG_fail;
53806 }
53807 resultobj = SWIG_Py_Void();
53808 return resultobj;
53809 fail:
53810 return NULL;
53811 }
53812
53813
53814 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53815 PyObject *resultobj = 0;
53816 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53817 wxWindow *arg2 = (wxWindow *) 0 ;
53818 bool result;
53819 void *argp1 = 0 ;
53820 int res1 = 0 ;
53821 void *argp2 = 0 ;
53822 int res2 = 0 ;
53823 PyObject * obj0 = 0 ;
53824 PyObject * obj1 = 0 ;
53825 char * kwnames[] = {
53826 (char *) "self",(char *) "otherW", NULL
53827 };
53828
53829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53831 if (!SWIG_IsOK(res1)) {
53832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53833 }
53834 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53835 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53836 if (!SWIG_IsOK(res2)) {
53837 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53838 }
53839 arg2 = reinterpret_cast< wxWindow * >(argp2);
53840 {
53841 PyThreadState* __tstate = wxPyBeginAllowThreads();
53842 result = (bool)(arg1)->ResetIfWin(arg2);
53843 wxPyEndAllowThreads(__tstate);
53844 if (PyErr_Occurred()) SWIG_fail;
53845 }
53846 {
53847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53848 }
53849 return resultobj;
53850 fail:
53851 return NULL;
53852 }
53853
53854
53855 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53856 PyObject *resultobj = 0;
53857 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53858 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53859 wxWindow *arg3 = (wxWindow *) 0 ;
53860 bool result;
53861 void *argp1 = 0 ;
53862 int res1 = 0 ;
53863 void *argp2 = 0 ;
53864 int res2 = 0 ;
53865 void *argp3 = 0 ;
53866 int res3 = 0 ;
53867 PyObject * obj0 = 0 ;
53868 PyObject * obj1 = 0 ;
53869 PyObject * obj2 = 0 ;
53870 char * kwnames[] = {
53871 (char *) "self",(char *) "constraints",(char *) "win", NULL
53872 };
53873
53874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53876 if (!SWIG_IsOK(res1)) {
53877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53878 }
53879 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53880 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53881 if (!SWIG_IsOK(res2)) {
53882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53883 }
53884 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53885 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53886 if (!SWIG_IsOK(res3)) {
53887 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53888 }
53889 arg3 = reinterpret_cast< wxWindow * >(argp3);
53890 {
53891 PyThreadState* __tstate = wxPyBeginAllowThreads();
53892 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53893 wxPyEndAllowThreads(__tstate);
53894 if (PyErr_Occurred()) SWIG_fail;
53895 }
53896 {
53897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53898 }
53899 return resultobj;
53900 fail:
53901 return NULL;
53902 }
53903
53904
53905 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53906 PyObject *resultobj = 0;
53907 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53908 wxEdge arg2 ;
53909 wxWindow *arg3 = (wxWindow *) 0 ;
53910 wxWindow *arg4 = (wxWindow *) 0 ;
53911 int result;
53912 void *argp1 = 0 ;
53913 int res1 = 0 ;
53914 int val2 ;
53915 int ecode2 = 0 ;
53916 void *argp3 = 0 ;
53917 int res3 = 0 ;
53918 void *argp4 = 0 ;
53919 int res4 = 0 ;
53920 PyObject * obj0 = 0 ;
53921 PyObject * obj1 = 0 ;
53922 PyObject * obj2 = 0 ;
53923 PyObject * obj3 = 0 ;
53924 char * kwnames[] = {
53925 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53926 };
53927
53928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53930 if (!SWIG_IsOK(res1)) {
53931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53932 }
53933 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53934 ecode2 = SWIG_AsVal_int(obj1, &val2);
53935 if (!SWIG_IsOK(ecode2)) {
53936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53937 }
53938 arg2 = static_cast< wxEdge >(val2);
53939 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53940 if (!SWIG_IsOK(res3)) {
53941 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53942 }
53943 arg3 = reinterpret_cast< wxWindow * >(argp3);
53944 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53945 if (!SWIG_IsOK(res4)) {
53946 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53947 }
53948 arg4 = reinterpret_cast< wxWindow * >(argp4);
53949 {
53950 PyThreadState* __tstate = wxPyBeginAllowThreads();
53951 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53952 wxPyEndAllowThreads(__tstate);
53953 if (PyErr_Occurred()) SWIG_fail;
53954 }
53955 resultobj = SWIG_From_int(static_cast< int >(result));
53956 return resultobj;
53957 fail:
53958 return NULL;
53959 }
53960
53961
53962 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53963 PyObject *obj;
53964 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53965 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53966 return SWIG_Py_Void();
53967 }
53968
53969 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53970 PyObject *resultobj = 0;
53971 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53972 wxIndividualLayoutConstraint *result = 0 ;
53973 void *argp1 = 0 ;
53974 int res1 = 0 ;
53975 PyObject *swig_obj[1] ;
53976
53977 if (!args) SWIG_fail;
53978 swig_obj[0] = args;
53979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53980 if (!SWIG_IsOK(res1)) {
53981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53982 }
53983 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53984 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53986 return resultobj;
53987 fail:
53988 return NULL;
53989 }
53990
53991
53992 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53993 PyObject *resultobj = 0;
53994 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53995 wxIndividualLayoutConstraint *result = 0 ;
53996 void *argp1 = 0 ;
53997 int res1 = 0 ;
53998 PyObject *swig_obj[1] ;
53999
54000 if (!args) SWIG_fail;
54001 swig_obj[0] = args;
54002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54003 if (!SWIG_IsOK(res1)) {
54004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54005 }
54006 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54007 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
54008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54009 return resultobj;
54010 fail:
54011 return NULL;
54012 }
54013
54014
54015 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54016 PyObject *resultobj = 0;
54017 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54018 wxIndividualLayoutConstraint *result = 0 ;
54019 void *argp1 = 0 ;
54020 int res1 = 0 ;
54021 PyObject *swig_obj[1] ;
54022
54023 if (!args) SWIG_fail;
54024 swig_obj[0] = args;
54025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54026 if (!SWIG_IsOK(res1)) {
54027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54028 }
54029 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54030 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
54031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54032 return resultobj;
54033 fail:
54034 return NULL;
54035 }
54036
54037
54038 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54039 PyObject *resultobj = 0;
54040 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54041 wxIndividualLayoutConstraint *result = 0 ;
54042 void *argp1 = 0 ;
54043 int res1 = 0 ;
54044 PyObject *swig_obj[1] ;
54045
54046 if (!args) SWIG_fail;
54047 swig_obj[0] = args;
54048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54049 if (!SWIG_IsOK(res1)) {
54050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54051 }
54052 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54053 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
54054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54055 return resultobj;
54056 fail:
54057 return NULL;
54058 }
54059
54060
54061 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54062 PyObject *resultobj = 0;
54063 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54064 wxIndividualLayoutConstraint *result = 0 ;
54065 void *argp1 = 0 ;
54066 int res1 = 0 ;
54067 PyObject *swig_obj[1] ;
54068
54069 if (!args) SWIG_fail;
54070 swig_obj[0] = args;
54071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54072 if (!SWIG_IsOK(res1)) {
54073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54074 }
54075 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54076 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
54077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54078 return resultobj;
54079 fail:
54080 return NULL;
54081 }
54082
54083
54084 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54085 PyObject *resultobj = 0;
54086 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54087 wxIndividualLayoutConstraint *result = 0 ;
54088 void *argp1 = 0 ;
54089 int res1 = 0 ;
54090 PyObject *swig_obj[1] ;
54091
54092 if (!args) SWIG_fail;
54093 swig_obj[0] = args;
54094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54095 if (!SWIG_IsOK(res1)) {
54096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54097 }
54098 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54099 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
54100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54101 return resultobj;
54102 fail:
54103 return NULL;
54104 }
54105
54106
54107 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54108 PyObject *resultobj = 0;
54109 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54110 wxIndividualLayoutConstraint *result = 0 ;
54111 void *argp1 = 0 ;
54112 int res1 = 0 ;
54113 PyObject *swig_obj[1] ;
54114
54115 if (!args) SWIG_fail;
54116 swig_obj[0] = args;
54117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54118 if (!SWIG_IsOK(res1)) {
54119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54120 }
54121 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54122 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
54123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54124 return resultobj;
54125 fail:
54126 return NULL;
54127 }
54128
54129
54130 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54131 PyObject *resultobj = 0;
54132 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54133 wxIndividualLayoutConstraint *result = 0 ;
54134 void *argp1 = 0 ;
54135 int res1 = 0 ;
54136 PyObject *swig_obj[1] ;
54137
54138 if (!args) SWIG_fail;
54139 swig_obj[0] = args;
54140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54141 if (!SWIG_IsOK(res1)) {
54142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54143 }
54144 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54145 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
54146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54147 return resultobj;
54148 fail:
54149 return NULL;
54150 }
54151
54152
54153 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54154 PyObject *resultobj = 0;
54155 wxLayoutConstraints *result = 0 ;
54156
54157 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
54158 {
54159 PyThreadState* __tstate = wxPyBeginAllowThreads();
54160 result = (wxLayoutConstraints *)new wxLayoutConstraints();
54161 wxPyEndAllowThreads(__tstate);
54162 if (PyErr_Occurred()) SWIG_fail;
54163 }
54164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
54165 return resultobj;
54166 fail:
54167 return NULL;
54168 }
54169
54170
54171 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54172 PyObject *resultobj = 0;
54173 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54174 void *argp1 = 0 ;
54175 int res1 = 0 ;
54176 PyObject *swig_obj[1] ;
54177
54178 if (!args) SWIG_fail;
54179 swig_obj[0] = args;
54180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
54181 if (!SWIG_IsOK(res1)) {
54182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54183 }
54184 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54185 {
54186 PyThreadState* __tstate = wxPyBeginAllowThreads();
54187 delete arg1;
54188
54189 wxPyEndAllowThreads(__tstate);
54190 if (PyErr_Occurred()) SWIG_fail;
54191 }
54192 resultobj = SWIG_Py_Void();
54193 return resultobj;
54194 fail:
54195 return NULL;
54196 }
54197
54198
54199 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54200 PyObject *resultobj = 0;
54201 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54202 wxWindow *arg2 = (wxWindow *) 0 ;
54203 int *arg3 = (int *) 0 ;
54204 bool result;
54205 void *argp1 = 0 ;
54206 int res1 = 0 ;
54207 void *argp2 = 0 ;
54208 int res2 = 0 ;
54209 int temp3 ;
54210 int res3 = SWIG_TMPOBJ ;
54211 PyObject * obj0 = 0 ;
54212 PyObject * obj1 = 0 ;
54213 char * kwnames[] = {
54214 (char *) "self",(char *) "win", NULL
54215 };
54216
54217 arg3 = &temp3;
54218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
54219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54220 if (!SWIG_IsOK(res1)) {
54221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54222 }
54223 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54225 if (!SWIG_IsOK(res2)) {
54226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
54227 }
54228 arg2 = reinterpret_cast< wxWindow * >(argp2);
54229 {
54230 PyThreadState* __tstate = wxPyBeginAllowThreads();
54231 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
54232 wxPyEndAllowThreads(__tstate);
54233 if (PyErr_Occurred()) SWIG_fail;
54234 }
54235 {
54236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54237 }
54238 if (SWIG_IsTmpObj(res3)) {
54239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
54240 } else {
54241 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
54242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
54243 }
54244 return resultobj;
54245 fail:
54246 return NULL;
54247 }
54248
54249
54250 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54251 PyObject *resultobj = 0;
54252 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54253 bool result;
54254 void *argp1 = 0 ;
54255 int res1 = 0 ;
54256 PyObject *swig_obj[1] ;
54257
54258 if (!args) SWIG_fail;
54259 swig_obj[0] = args;
54260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54261 if (!SWIG_IsOK(res1)) {
54262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
54263 }
54264 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54265 {
54266 PyThreadState* __tstate = wxPyBeginAllowThreads();
54267 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
54268 wxPyEndAllowThreads(__tstate);
54269 if (PyErr_Occurred()) SWIG_fail;
54270 }
54271 {
54272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54273 }
54274 return resultobj;
54275 fail:
54276 return NULL;
54277 }
54278
54279
54280 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54281 PyObject *obj;
54282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54283 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
54284 return SWIG_Py_Void();
54285 }
54286
54287 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54288 return SWIG_Python_InitShadowInstance(args);
54289 }
54290
54291 static PyMethodDef SwigMethods[] = {
54292 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
54293 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
54294 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
54295 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
54296 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
54297 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
54298 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
54299 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
54300 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54301 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
54302 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54303 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54304 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54305 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54306 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
54307 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
54309 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
54310 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54311 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54312 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54313 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54314 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
54315 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
54316 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
54317 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
54318 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
54319 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
54320 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
54321 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
54322 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
54323 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
54324 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
54325 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54326 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
54327 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54329 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54331 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54332 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
54333 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
54334 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
54335 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
54336 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
54337 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
54338 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
54339 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
54341 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54342 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54343 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54344 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54345 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
54349 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
54350 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
54351 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
54352 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
54356 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
54357 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
54358 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
54359 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
54360 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
54361 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
54363 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54364 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
54365 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
54367 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
54369 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
54370 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54371 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
54372 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
54374 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
54375 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
54376 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54377 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
54378 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
54379 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
54380 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
54381 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
54383 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
54385 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
54386 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
54390 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54394 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54395 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
54396 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
54401 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
54402 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
54403 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
54404 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
54405 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
54406 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
54407 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
54408 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54409 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
54410 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
54411 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
54412 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
54414 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54416 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
54417 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
54418 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
54419 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
54420 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
54421 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
54422 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
54423 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
54428 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54429 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54430 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
54431 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
54432 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54433 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
54435 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
54436 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
54437 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
54438 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54439 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
54440 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
54441 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
54442 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
54444 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
54445 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
54446 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
54447 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
54448 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
54452 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
54453 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
54454 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
54455 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
54456 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
54457 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
54460 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
54461 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
54462 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
54463 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
54464 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
54465 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
54466 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
54467 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
54468 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
54469 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
54470 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
54471 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
54472 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
54473 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
54474 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
54475 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
54476 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
54477 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
54478 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54481 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54482 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
54483 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
54484 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
54489 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
54490 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
54491 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
54492 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
54493 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
54494 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
54497 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54498 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54499 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
54500 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
54501 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
54502 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
54503 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
54504 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
54505 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
54508 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
54509 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
54510 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54511 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54512 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54513 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
54514 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
54515 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
54516 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
54517 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54518 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
54519 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
54520 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54521 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54522 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54523 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54524 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
54525 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
54526 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
54527 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
54528 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
54529 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
54530 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
54531 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54532 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54533 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54534 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
54535 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
54536 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
54537 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
54538 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
54539 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54540 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54541 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54542 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54543 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54544 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54545 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54546 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54547 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54548 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54549 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54550 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54551 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54552 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54553 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54554 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54555 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54556 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54557 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54558 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54559 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54560 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54561 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54562 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54563 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54564 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54565 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54566 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54567 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54568 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54569 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54570 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54571 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54572 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54573 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54574 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54575 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54576 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54577 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54578 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54579 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54580 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
54581 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
54582 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
54583 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
54584 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
54585 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54586 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54587 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54588 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54589 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54590 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54591 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54592 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54593 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54594 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54595 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54596 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54597 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54598 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54599 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54600 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54601 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54604 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54605 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54607 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54608 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54609 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54610 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54611 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
54612 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54613 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54614 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54615 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54616 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54617 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54618 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54619 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54620 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54621 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54622 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54623 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54624 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54625 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54626 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54627 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54629 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54630 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54631 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54632 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54634 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54635 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54636 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54637 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54638 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54639 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54640 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54641 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54642 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54643 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54644 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54645 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54646 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54647 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54648 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54649 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54650 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54651 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54652 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54653 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54654 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54655 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54656 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54657 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54658 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54659 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54660 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54661 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54662 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54663 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54664 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54665 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54666 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54667 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54668 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54669 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54670 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54671 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54672 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54673 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54674 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54675 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54676 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54677 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54678 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54679 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54680 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54681 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54682 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54683 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54684 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54685 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54686 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54687 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54688 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54689 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54690 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54691 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54692 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54693 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54694 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54695 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54696 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54697 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54698 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54699 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54700 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54701 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54702 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54703 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54704 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54705 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
54706 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
54707 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
54708 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54709 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54710 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54711 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54712 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54713 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54714 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54715 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54716 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54717 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54718 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54719 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54720 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54721 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54722 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54723 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54724 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54725 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54726 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54727 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54728 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54729 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54730 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54731 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54732 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54733 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54734 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54735 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54736 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54737 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54738 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54739 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54740 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54741 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54742 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54743 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54744 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54745 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54746 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54747 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54748 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54749 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54750 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54751 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54752 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54753 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54754 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54755 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54756 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54757 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54758 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54759 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54760 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54761 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54762 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54763 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54764 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54765 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54766 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54767 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54768 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54769 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54770 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54771 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54772 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54773 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54774 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54775 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54776 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54777 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54778 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54779 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54780 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54781 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54782 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54783 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54784 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54785 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54786 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54787 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54788 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54789 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54790 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54791 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54792 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54793 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54794 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54795 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54796 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54797 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54798 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54799 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54800 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54801 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54802 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54803 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54804 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54805 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54806 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54807 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54808 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54809 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54810 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54811 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54812 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54813 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54814 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54815 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54816 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54817 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54818 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54819 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54820 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54821 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54822 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54823 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54824 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54825 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54826 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54827 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54828 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54829 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54830 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54831 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54832 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54833 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54834 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54835 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54836 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54837 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54838 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54839 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54840 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54841 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54842 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54843 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54844 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54845 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54846 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54847 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54848 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54849 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54850 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54851 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54852 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54853 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54854 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54855 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54856 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54857 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54858 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54859 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54860 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54861 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54862 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54863 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54864 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54865 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54866 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54867 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54868 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54869 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54870 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54871 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54872 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54873 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54874 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54875 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54876 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54877 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54878 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54879 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54880 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54881 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54882 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54883 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54884 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54885 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54886 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54887 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54888 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54889 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54890 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54891 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54892 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54893 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54894 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54895 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54896 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54897 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54898 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54899 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54900 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54901 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54902 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54903 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54904 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54905 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54906 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54907 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54908 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54909 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54910 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54911 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54912 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54913 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54914 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54915 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54916 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54917 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54918 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54919 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54920 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54921 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54922 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54923 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54924 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54925 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54926 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54927 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54928 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54929 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54930 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54931 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54932 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54933 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54934 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54935 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54936 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54937 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54938 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54939 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54940 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54941 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54942 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54943 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54944 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54945 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54946 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54947 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54948 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54949 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54950 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54951 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54952 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54953 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54954 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54955 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54956 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54957 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54958 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54959 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54960 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54961 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54962 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54963 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54964 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54965 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54966 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54967 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54968 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54969 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54970 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54971 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54972 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54973 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54974 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54975 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54976 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54977 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54978 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54979 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54980 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54981 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54982 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54983 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54984 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54985 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54986 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54987 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54988 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54989 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54990 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54991 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54992 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54993 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54994 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54995 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54996 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54997 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54998 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54999 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55000 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
55001 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
55002 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
55003 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
55004 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
55005 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
55006 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55007 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
55008 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
55009 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
55010 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
55011 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
55012 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
55013 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
55014 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
55015 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
55016 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55017 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
55018 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
55019 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
55020 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55021 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
55022 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
55023 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
55024 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55025 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
55026 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55027 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
55028 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
55029 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
55030 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
55031 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
55032 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
55033 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
55034 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
55035 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
55036 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
55037 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55038 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
55039 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
55040 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55041 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
55042 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55043 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
55044 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
55045 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
55046 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55047 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
55048 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55049 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
55050 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
55051 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
55052 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55053 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
55054 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
55055 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
55056 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
55057 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
55058 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
55059 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55060 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
55061 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
55062 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
55063 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
55064 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
55065 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
55066 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
55067 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
55068 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
55069 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
55070 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
55071 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
55072 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
55073 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
55074 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
55075 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
55076 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
55077 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
55078 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
55079 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
55080 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55081 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
55082 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
55083 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
55084 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
55085 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
55086 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
55087 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
55088 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
55089 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
55090 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
55091 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
55092 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
55093 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
55094 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
55095 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
55096 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55097 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55098 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55099 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
55100 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
55101 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
55102 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
55103 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
55104 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
55105 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
55106 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
55107 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
55108 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
55109 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
55110 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55111 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
55112 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
55113 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
55114 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
55115 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
55116 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
55117 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
55118 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
55119 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
55120 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
55121 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
55122 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
55123 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
55124 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
55125 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
55126 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
55127 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
55128 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
55129 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
55130 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
55131 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
55132 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55133 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55134 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
55135 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
55136 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
55137 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
55138 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
55139 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
55140 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
55141 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
55142 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55143 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
55144 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
55145 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
55146 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
55147 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
55148 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
55149 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
55150 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
55151 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
55152 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
55153 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
55154 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
55155 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
55156 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
55157 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
55158 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
55159 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
55160 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55161 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
55162 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
55163 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
55164 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
55165 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55166 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
55167 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
55168 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
55169 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
55170 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
55171 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55172 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
55173 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
55174 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55175 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55176 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
55177 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55178 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55179 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
55180 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
55181 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
55182 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55183 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
55184 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
55185 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
55186 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
55187 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
55188 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
55189 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55190 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
55191 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
55192 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
55193 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
55194 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
55195 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
55196 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
55197 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
55198 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
55199 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
55200 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
55201 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
55202 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
55203 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
55204 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
55205 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
55206 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
55207 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
55208 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
55209 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
55210 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
55211 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
55212 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
55213 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55214 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55215 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55216 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55217 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
55218 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
55219 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55220 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
55221 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
55222 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
55223 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
55224 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
55225 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
55226 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55227 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
55228 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
55229 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
55230 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55231 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
55232 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55233 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
55234 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
55235 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
55236 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
55237 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55238 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
55239 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55240 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
55241 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55242 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
55243 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
55244 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55245 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
55246 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
55247 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
55248 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
55249 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
55250 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
55251 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
55252 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55253 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55254 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
55255 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
55256 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
55257 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
55258 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
55259 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
55260 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
55261 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
55262 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55263 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55264 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
55265 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55266 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55267 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55268 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55269 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
55270 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
55271 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
55272 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
55273 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
55274 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
55275 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55276 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
55277 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55278 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55279 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55280 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55281 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
55282 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
55283 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55284 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55285 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
55286 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
55287 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
55288 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
55289 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
55290 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
55291 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
55292 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
55293 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
55294 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
55295 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
55296 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
55297 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
55298 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
55299 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
55300 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
55301 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
55302 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55303 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
55304 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
55305 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55306 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55307 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55308 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55309 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55310 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
55311 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
55312 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
55313 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
55314 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55315 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
55316 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
55317 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
55318 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
55319 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55320 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
55321 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
55322 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
55323 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
55324 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
55325 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
55326 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55327 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55328 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
55329 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
55330 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
55331 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
55332 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
55333 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
55334 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
55335 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
55336 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
55337 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55338 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
55339 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
55340 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
55341 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
55342 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55343 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55344 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55345 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55346 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
55347 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
55348 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55349 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
55350 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
55351 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
55352 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
55353 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
55354 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
55355 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
55356 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
55357 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55358 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
55359 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
55360 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
55361 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
55362 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
55363 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
55364 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
55365 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55366 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
55367 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
55368 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
55369 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
55370 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55371 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
55372 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
55373 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55374 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
55375 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
55376 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
55377 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
55378 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
55379 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
55380 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
55381 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55382 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55383 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55384 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
55385 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
55386 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
55387 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
55388 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
55389 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
55390 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
55391 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
55392 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55393 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
55394 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
55395 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
55396 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
55397 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
55398 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55399 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
55400 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
55401 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
55402 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55403 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
55404 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55405 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55406 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55407 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55408 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
55409 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55410 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55411 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
55412 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55413 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
55414 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55415 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55416 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55417 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55418 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
55419 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55420 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55421 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55422 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55423 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
55424 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55425 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
55426 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
55427 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
55428 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
55429 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
55430 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
55431 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
55432 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55433 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55434 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55435 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55436 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55437 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55438 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55439 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55440 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55441 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55442 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
55443 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
55444 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55445 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
55446 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55447 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
55448 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
55449 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
55450 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
55451 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55452 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
55453 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
55454 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
55455 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
55456 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
55457 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
55458 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
55459 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55460 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55461 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
55462 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55463 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
55464 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55465 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
55466 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
55467 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55468 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55469 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55470 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55471 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55472 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55473 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55474 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55475 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55476 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55477 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55478 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55479 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55480 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
55481 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
55482 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55483 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
55484 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
55485 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55486 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
55487 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
55488 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
55489 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55490 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
55491 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
55492 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55493 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55494 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
55495 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
55496 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55497 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
55498 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
55499 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
55500 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
55501 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
55502 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
55503 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
55504 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
55505 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55506 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
55507 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55508 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
55509 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55510 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
55511 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
55512 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
55513 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
55514 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
55515 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
55516 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55517 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
55518 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55519 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
55520 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
55521 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
55522 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55523 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
55524 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
55525 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55526 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
55527 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
55528 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
55529 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
55530 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
55531 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
55532 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
55533 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
55534 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
55535 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
55536 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
55537 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55538 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
55539 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
55540 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
55541 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55542 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
55543 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
55544 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55545 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
55546 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55547 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55548 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55549 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55550 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55551 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55552 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55553 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55554 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55555 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55556 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55557 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55558 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55559 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55560 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55561 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55562 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55563 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55564 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55565 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55566 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55567 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55568 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55569 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55570 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55571 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55572 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55573 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55574 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55575 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55576 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55577 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55578 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55579 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55580 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55581 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55582 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55583 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55584 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55585 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55586 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55587 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55588 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55589 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55590 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55591 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55592 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55593 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55594 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55595 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55596 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55597 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55598 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55599 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55600 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55601 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55602 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55603 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55604 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55605 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55606 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55607 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55608 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55609 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55610 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55611 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55612 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55613 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55614 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55615 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55616 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55617 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55618 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55619 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55620 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55621 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55622 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55623 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55624 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55625 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55626 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55627 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55628 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55629 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55630 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55631 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55632 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55633 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55634 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55635 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55636 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55637 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55638 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55639 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55640 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55641 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55642 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55643 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55644 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55645 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55646 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55647 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55648 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55649 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55650 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55651 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55652 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55653 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55654 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55655 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55656 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55657 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55658 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55659 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55660 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55661 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55662 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55663 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55664 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55665 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55666 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55667 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55668 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55669 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55670 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55671 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55672 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55673 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55674 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55675 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55676 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55677 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55678 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55679 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55680 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55681 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55682 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55683 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55684 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55685 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55686 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55687 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55688 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55689 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55690 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55691 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55692 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55693 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55694 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55695 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55696 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55697 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55698 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55699 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55700 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55701 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55702 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55703 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55704 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55705 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55706 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55707 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55708 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55709 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55710 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55711 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55712 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55713 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55714 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55715 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55716 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55717 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55718 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55719 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55720 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55721 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55722 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55723 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55724 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55725 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55726 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55727 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55728 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55729 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55730 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55731 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55732 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55733 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55734 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55735 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55736 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55737 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55738 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55739 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55740 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55741 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55742 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55743 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55744 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55745 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55746 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55747 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55748 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55749 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55750 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55751 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55752 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55753 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55754 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55755 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55756 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55757 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55758 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55759 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55760 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55761 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55762 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55763 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55764 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55765 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55766 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55767 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55768 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55769 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55770 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55771 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55772 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55773 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55774 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55775 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55776 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55777 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55778 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55779 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55780 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55781 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55782 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55783 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55784 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55785 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55786 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55787 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55788 { NULL, NULL, 0, NULL }
55789 };
55790
55791
55792 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55793
55794 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55795 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55796 }
55797 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55798 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55799 }
55800 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55801 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55802 }
55803 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55804 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55805 }
55806 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55807 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55808 }
55809 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55810 return (void *)((wxSizer *) ((wxGridSizer *) x));
55811 }
55812 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55813 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55814 }
55815 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55816 return (void *)((wxSizer *) ((wxPySizer *) x));
55817 }
55818 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55819 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55820 }
55821 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55822 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55823 }
55824 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55825 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55826 }
55827 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55828 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55829 }
55830 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55831 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55832 }
55833 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55834 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55835 }
55836 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55837 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55838 }
55839 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55840 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55841 }
55842 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55843 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55844 }
55845 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55846 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55847 }
55848 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55849 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55850 }
55851 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55852 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55853 }
55854 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55855 return (void *)((wxEvent *) ((wxPyEvent *) x));
55856 }
55857 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55858 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55859 }
55860 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55861 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55862 }
55863 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55864 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55865 }
55866 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55867 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55868 }
55869 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55870 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55871 }
55872 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55873 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55874 }
55875 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55876 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55877 }
55878 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55879 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55880 }
55881 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55882 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55883 }
55884 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55885 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55886 }
55887 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55888 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55889 }
55890 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55891 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55892 }
55893 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55894 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55895 }
55896 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55897 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55898 }
55899 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55900 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55901 }
55902 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55903 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55904 }
55905 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55906 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55907 }
55908 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55909 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55910 }
55911 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55912 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55913 }
55914 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55915 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55916 }
55917 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55918 return (void *)((wxEvent *) ((wxShowEvent *) x));
55919 }
55920 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55921 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55922 }
55923 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55924 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55925 }
55926 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55927 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55928 }
55929 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55930 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55931 }
55932 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55933 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55934 }
55935 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55936 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55937 }
55938 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55939 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55940 }
55941 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55942 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55943 }
55944 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55945 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55946 }
55947 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55948 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55949 }
55950 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55951 return (void *)((wxControl *) ((wxControlWithItems *) x));
55952 }
55953 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55954 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55955 }
55956 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55957 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55958 }
55959 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55960 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55961 }
55962 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55963 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55964 }
55965 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55966 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55967 }
55968 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55969 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55970 }
55971 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55972 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55973 }
55974 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55975 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55976 }
55977 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55978 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55979 }
55980 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55981 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55982 }
55983 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55984 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55985 }
55986 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55987 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55988 }
55989 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55990 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55991 }
55992 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55993 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55994 }
55995 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55996 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55997 }
55998 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55999 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
56000 }
56001 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
56002 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
56003 }
56004 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
56005 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56006 }
56007 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
56008 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56009 }
56010 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
56011 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
56012 }
56013 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
56014 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
56015 }
56016 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
56017 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
56018 }
56019 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
56020 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
56021 }
56022 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
56023 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
56024 }
56025 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
56026 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
56027 }
56028 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
56029 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
56030 }
56031 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
56032 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
56033 }
56034 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
56035 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
56036 }
56037 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
56038 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
56039 }
56040 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
56041 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
56042 }
56043 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
56044 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
56045 }
56046 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
56047 return (void *)((wxObject *) ((wxSizerItem *) x));
56048 }
56049 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
56050 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
56051 }
56052 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
56053 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
56054 }
56055 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
56056 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
56057 }
56058 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
56059 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
56060 }
56061 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
56062 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
56063 }
56064 static void *_p_wxSizerTo_p_wxObject(void *x) {
56065 return (void *)((wxObject *) ((wxSizer *) x));
56066 }
56067 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
56068 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
56069 }
56070 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
56071 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
56072 }
56073 static void *_p_wxEventTo_p_wxObject(void *x) {
56074 return (void *)((wxObject *) ((wxEvent *) x));
56075 }
56076 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
56077 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
56078 }
56079 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
56080 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
56081 }
56082 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
56083 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
56084 }
56085 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
56086 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
56087 }
56088 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
56089 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
56090 }
56091 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
56092 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
56093 }
56094 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
56095 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
56096 }
56097 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
56098 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
56099 }
56100 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
56101 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
56102 }
56103 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
56104 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
56105 }
56106 static void *_p_wxControlTo_p_wxObject(void *x) {
56107 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
56108 }
56109 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
56110 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
56111 }
56112 static void *_p_wxFSFileTo_p_wxObject(void *x) {
56113 return (void *)((wxObject *) ((wxFSFile *) x));
56114 }
56115 static void *_p_wxPySizerTo_p_wxObject(void *x) {
56116 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
56117 }
56118 static void *_p_wxPyEventTo_p_wxObject(void *x) {
56119 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
56120 }
56121 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
56122 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
56123 }
56124 static void *_p_wxShowEventTo_p_wxObject(void *x) {
56125 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
56126 }
56127 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
56128 return (void *)((wxObject *) ((wxMenuItem *) x));
56129 }
56130 static void *_p_wxDateEventTo_p_wxObject(void *x) {
56131 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
56132 }
56133 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
56134 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
56135 }
56136 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
56137 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
56138 }
56139 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
56140 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
56141 }
56142 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
56143 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
56144 }
56145 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
56146 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
56147 }
56148 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
56149 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
56150 }
56151 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
56152 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
56153 }
56154 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
56155 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
56156 }
56157 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
56158 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
56159 }
56160 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
56161 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
56162 }
56163 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
56164 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
56165 }
56166 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
56167 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
56168 }
56169 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
56170 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
56171 }
56172 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
56173 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56174 }
56175 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
56176 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56177 }
56178 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
56179 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
56180 }
56181 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
56182 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
56183 }
56184 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
56185 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
56186 }
56187 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
56188 return (void *)((wxObject *) ((wxImageHandler *) x));
56189 }
56190 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
56191 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
56192 }
56193 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
56194 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
56195 }
56196 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
56197 return (void *)((wxObject *) ((wxEvtHandler *) x));
56198 }
56199 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
56200 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
56201 }
56202 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
56203 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
56204 }
56205 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
56206 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
56207 }
56208 static void *_p_wxImageTo_p_wxObject(void *x) {
56209 return (void *)((wxObject *) ((wxImage *) x));
56210 }
56211 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
56212 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
56213 }
56214 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
56215 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56216 }
56217 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
56218 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
56219 }
56220 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
56221 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
56222 }
56223 static void *_p_wxWindowTo_p_wxObject(void *x) {
56224 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
56225 }
56226 static void *_p_wxMenuTo_p_wxObject(void *x) {
56227 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
56228 }
56229 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
56230 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
56231 }
56232 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
56233 return (void *)((wxObject *) ((wxFileSystem *) x));
56234 }
56235 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
56236 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
56237 }
56238 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
56239 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
56240 }
56241 static void *_p_wxPyAppTo_p_wxObject(void *x) {
56242 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
56243 }
56244 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
56245 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
56246 }
56247 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
56248 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
56249 }
56250 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
56251 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
56252 }
56253 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
56254 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
56255 }
56256 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
56257 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
56258 }
56259 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
56260 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
56261 }
56262 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
56263 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
56264 }
56265 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
56266 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
56267 }
56268 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
56269 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
56270 }
56271 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
56272 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
56273 }
56274 static void *_p_wxValidatorTo_p_wxObject(void *x) {
56275 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
56276 }
56277 static void *_p_wxControlTo_p_wxWindow(void *x) {
56278 return (void *)((wxWindow *) ((wxControl *) x));
56279 }
56280 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
56281 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
56282 }
56283 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
56284 return (void *)((wxWindow *) ((wxMenuBar *) x));
56285 }
56286 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
56287 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
56288 }
56289 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
56290 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
56291 }
56292 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
56293 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
56294 }
56295 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
56296 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
56297 }
56298 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
56299 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
56300 }
56301 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
56302 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
56303 }
56304 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
56305 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56306 }
56307 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
56308 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
56309 }
56310 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
56311 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
56312 }
56313 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
56314 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
56315 }
56316 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
56317 return (void *)((wxValidator *) ((wxPyValidator *) x));
56318 }
56319 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
56320 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
56321 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};
56322 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
56323 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
56324 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
56325 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
56326 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
56327 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
56328 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
56329 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
56330 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
56331 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
56332 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
56333 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
56334 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
56335 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
56336 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
56337 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
56338 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
56339 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
56340 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
56341 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
56342 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
56343 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
56344 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
56345 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
56346 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
56347 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
56348 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
56349 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
56350 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
56351 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
56352 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
56353 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
56354 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
56355 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
56356 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
56357 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
56358 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
56359 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
56360 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
56361 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
56362 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
56363 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
56364 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
56365 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
56366 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
56367 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
56368 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
56369 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
56370 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
56371 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
56372 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
56373 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
56374 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
56375 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
56376 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
56377 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
56378 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
56379 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
56380 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
56381 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
56382 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
56383 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
56384 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
56385 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
56386 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
56387 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
56388 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
56389 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
56390 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
56391 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
56392 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
56393 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
56394 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
56395 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
56396 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
56397 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
56398 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
56399 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
56400 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
56401 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
56402 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
56403 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
56404 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
56405 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
56406 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
56407 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
56408 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
56409 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
56410 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
56411 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
56412 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
56413 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
56414 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
56415 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
56416 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
56417 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
56418 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
56419 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
56420 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
56421 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
56422 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
56423 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
56424 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
56425 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
56426 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
56427 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
56428 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
56429 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
56430 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
56431 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
56432 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
56433 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
56434 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
56435 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
56436 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
56437 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
56438 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
56439 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
56440 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
56441 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
56442 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
56443 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
56444 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
56445 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
56446 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
56447 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
56448 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
56449 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
56450 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
56451
56452 static swig_type_info *swig_type_initial[] = {
56453 &_swigt__p_buffer,
56454 &_swigt__p_char,
56455 &_swigt__p_form_ops_t,
56456 &_swigt__p_int,
56457 &_swigt__p_long,
56458 &_swigt__p_unsigned_char,
56459 &_swigt__p_unsigned_int,
56460 &_swigt__p_unsigned_long,
56461 &_swigt__p_wxANIHandler,
56462 &_swigt__p_wxAcceleratorEntry,
56463 &_swigt__p_wxAcceleratorTable,
56464 &_swigt__p_wxActivateEvent,
56465 &_swigt__p_wxAppTraits,
56466 &_swigt__p_wxArrayString,
56467 &_swigt__p_wxBMPHandler,
56468 &_swigt__p_wxBitmap,
56469 &_swigt__p_wxBoxSizer,
56470 &_swigt__p_wxButton,
56471 &_swigt__p_wxCURHandler,
56472 &_swigt__p_wxCaret,
56473 &_swigt__p_wxChildFocusEvent,
56474 &_swigt__p_wxClipboardTextEvent,
56475 &_swigt__p_wxCloseEvent,
56476 &_swigt__p_wxColour,
56477 &_swigt__p_wxCommandEvent,
56478 &_swigt__p_wxContextMenuEvent,
56479 &_swigt__p_wxControl,
56480 &_swigt__p_wxControlWithItems,
56481 &_swigt__p_wxCursor,
56482 &_swigt__p_wxDC,
56483 &_swigt__p_wxDateEvent,
56484 &_swigt__p_wxDateTime,
56485 &_swigt__p_wxDisplayChangedEvent,
56486 &_swigt__p_wxDropFilesEvent,
56487 &_swigt__p_wxDuplexMode,
56488 &_swigt__p_wxEraseEvent,
56489 &_swigt__p_wxEvent,
56490 &_swigt__p_wxEventLoop,
56491 &_swigt__p_wxEventLoopActivator,
56492 &_swigt__p_wxEvtHandler,
56493 &_swigt__p_wxFSFile,
56494 &_swigt__p_wxFileSystem,
56495 &_swigt__p_wxFileSystemHandler,
56496 &_swigt__p_wxFlexGridSizer,
56497 &_swigt__p_wxFocusEvent,
56498 &_swigt__p_wxFont,
56499 &_swigt__p_wxFrame,
56500 &_swigt__p_wxGBPosition,
56501 &_swigt__p_wxGBSizerItem,
56502 &_swigt__p_wxGBSpan,
56503 &_swigt__p_wxGIFHandler,
56504 &_swigt__p_wxGridBagSizer,
56505 &_swigt__p_wxGridSizer,
56506 &_swigt__p_wxHelpEvent__Origin,
56507 &_swigt__p_wxICOHandler,
56508 &_swigt__p_wxIconizeEvent,
56509 &_swigt__p_wxIdleEvent,
56510 &_swigt__p_wxImage,
56511 &_swigt__p_wxImageHandler,
56512 &_swigt__p_wxImageHistogram,
56513 &_swigt__p_wxImage_HSVValue,
56514 &_swigt__p_wxImage_RGBValue,
56515 &_swigt__p_wxIndividualLayoutConstraint,
56516 &_swigt__p_wxInitDialogEvent,
56517 &_swigt__p_wxInputStream,
56518 &_swigt__p_wxInternetFSHandler,
56519 &_swigt__p_wxItemContainer,
56520 &_swigt__p_wxJPEGHandler,
56521 &_swigt__p_wxKeyEvent,
56522 &_swigt__p_wxLayoutConstraints,
56523 &_swigt__p_wxMaximizeEvent,
56524 &_swigt__p_wxMemoryFSHandler,
56525 &_swigt__p_wxMenu,
56526 &_swigt__p_wxMenuBar,
56527 &_swigt__p_wxMenuBarBase,
56528 &_swigt__p_wxMenuEvent,
56529 &_swigt__p_wxMenuItem,
56530 &_swigt__p_wxMouseCaptureChangedEvent,
56531 &_swigt__p_wxMouseCaptureLostEvent,
56532 &_swigt__p_wxMouseEvent,
56533 &_swigt__p_wxMoveEvent,
56534 &_swigt__p_wxNavigationKeyEvent,
56535 &_swigt__p_wxNcPaintEvent,
56536 &_swigt__p_wxNotifyEvent,
56537 &_swigt__p_wxObject,
56538 &_swigt__p_wxOutputStream,
56539 &_swigt__p_wxPCXHandler,
56540 &_swigt__p_wxPNGHandler,
56541 &_swigt__p_wxPNMHandler,
56542 &_swigt__p_wxPaintEvent,
56543 &_swigt__p_wxPaletteChangedEvent,
56544 &_swigt__p_wxPaperSize,
56545 &_swigt__p_wxPoint,
56546 &_swigt__p_wxPoint2D,
56547 &_swigt__p_wxPropagateOnce,
56548 &_swigt__p_wxPropagationDisabler,
56549 &_swigt__p_wxPyApp,
56550 &_swigt__p_wxPyCommandEvent,
56551 &_swigt__p_wxPyDropTarget,
56552 &_swigt__p_wxPyEvent,
56553 &_swigt__p_wxPyFileSystemHandler,
56554 &_swigt__p_wxPyImageHandler,
56555 &_swigt__p_wxPyInputStream,
56556 &_swigt__p_wxPySizer,
56557 &_swigt__p_wxPyValidator,
56558 &_swigt__p_wxQuantize,
56559 &_swigt__p_wxQueryNewPaletteEvent,
56560 &_swigt__p_wxRealPoint,
56561 &_swigt__p_wxRect,
56562 &_swigt__p_wxRegion,
56563 &_swigt__p_wxScrollEvent,
56564 &_swigt__p_wxScrollWinEvent,
56565 &_swigt__p_wxSetCursorEvent,
56566 &_swigt__p_wxShowEvent,
56567 &_swigt__p_wxSize,
56568 &_swigt__p_wxSizeEvent,
56569 &_swigt__p_wxSizer,
56570 &_swigt__p_wxSizerItem,
56571 &_swigt__p_wxStaticBox,
56572 &_swigt__p_wxStaticBoxSizer,
56573 &_swigt__p_wxStdDialogButtonSizer,
56574 &_swigt__p_wxSysColourChangedEvent,
56575 &_swigt__p_wxTIFFHandler,
56576 &_swigt__p_wxToolTip,
56577 &_swigt__p_wxUpdateUIEvent,
56578 &_swigt__p_wxValidator,
56579 &_swigt__p_wxVisualAttributes,
56580 &_swigt__p_wxWindow,
56581 &_swigt__p_wxWindowCreateEvent,
56582 &_swigt__p_wxWindowDestroyEvent,
56583 &_swigt__p_wxXPMHandler,
56584 &_swigt__p_wxZipFSHandler,
56585 };
56586
56587 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56588 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56589 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56590 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56591 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56592 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56593 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56594 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56595 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56596 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56597 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56598 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56599 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56600 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56601 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}};
56602 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56603 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}};
56604 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56605 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}};
56606 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56607 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56608 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56609 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56610 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56611 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}};
56612 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56613 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}};
56614 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56615 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56616 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56617 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56618 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56619 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56620 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56621 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56622 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56623 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
56624 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56625 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56626 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}};
56627 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56628 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56629 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}};
56630 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}};
56631 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56632 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56633 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56634 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56635 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56636 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56637 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56638 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56639 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}};
56640 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56641 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}};
56642 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56643 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56644 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56645 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}};
56646 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56647 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56648 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56649 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56650 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56651 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56652 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56653 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}};
56654 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56655 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56656 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56657 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56658 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56659 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56660 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56661 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56662 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56663 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56664 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56665 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56666 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56667 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56668 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56669 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56670 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56671 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
56672 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56673 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56674 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56675 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56676 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56677 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56678 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56679 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56680 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56681 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56682 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56683 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56684 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56685 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56686 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56687 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56688 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56689 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56690 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56691 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56692 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56693 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56694 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56695 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56696 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56697 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56698 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56699 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56700 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56701 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56702 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56703 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}};
56704 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}};
56705 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56706 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56707 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56708 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56709 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56710 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56711 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56712 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}};
56713 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56714 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}};
56715 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56716 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56717 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56718 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56719
56720 static swig_cast_info *swig_cast_initial[] = {
56721 _swigc__p_buffer,
56722 _swigc__p_char,
56723 _swigc__p_form_ops_t,
56724 _swigc__p_int,
56725 _swigc__p_long,
56726 _swigc__p_unsigned_char,
56727 _swigc__p_unsigned_int,
56728 _swigc__p_unsigned_long,
56729 _swigc__p_wxANIHandler,
56730 _swigc__p_wxAcceleratorEntry,
56731 _swigc__p_wxAcceleratorTable,
56732 _swigc__p_wxActivateEvent,
56733 _swigc__p_wxAppTraits,
56734 _swigc__p_wxArrayString,
56735 _swigc__p_wxBMPHandler,
56736 _swigc__p_wxBitmap,
56737 _swigc__p_wxBoxSizer,
56738 _swigc__p_wxButton,
56739 _swigc__p_wxCURHandler,
56740 _swigc__p_wxCaret,
56741 _swigc__p_wxChildFocusEvent,
56742 _swigc__p_wxClipboardTextEvent,
56743 _swigc__p_wxCloseEvent,
56744 _swigc__p_wxColour,
56745 _swigc__p_wxCommandEvent,
56746 _swigc__p_wxContextMenuEvent,
56747 _swigc__p_wxControl,
56748 _swigc__p_wxControlWithItems,
56749 _swigc__p_wxCursor,
56750 _swigc__p_wxDC,
56751 _swigc__p_wxDateEvent,
56752 _swigc__p_wxDateTime,
56753 _swigc__p_wxDisplayChangedEvent,
56754 _swigc__p_wxDropFilesEvent,
56755 _swigc__p_wxDuplexMode,
56756 _swigc__p_wxEraseEvent,
56757 _swigc__p_wxEvent,
56758 _swigc__p_wxEventLoop,
56759 _swigc__p_wxEventLoopActivator,
56760 _swigc__p_wxEvtHandler,
56761 _swigc__p_wxFSFile,
56762 _swigc__p_wxFileSystem,
56763 _swigc__p_wxFileSystemHandler,
56764 _swigc__p_wxFlexGridSizer,
56765 _swigc__p_wxFocusEvent,
56766 _swigc__p_wxFont,
56767 _swigc__p_wxFrame,
56768 _swigc__p_wxGBPosition,
56769 _swigc__p_wxGBSizerItem,
56770 _swigc__p_wxGBSpan,
56771 _swigc__p_wxGIFHandler,
56772 _swigc__p_wxGridBagSizer,
56773 _swigc__p_wxGridSizer,
56774 _swigc__p_wxHelpEvent__Origin,
56775 _swigc__p_wxICOHandler,
56776 _swigc__p_wxIconizeEvent,
56777 _swigc__p_wxIdleEvent,
56778 _swigc__p_wxImage,
56779 _swigc__p_wxImageHandler,
56780 _swigc__p_wxImageHistogram,
56781 _swigc__p_wxImage_HSVValue,
56782 _swigc__p_wxImage_RGBValue,
56783 _swigc__p_wxIndividualLayoutConstraint,
56784 _swigc__p_wxInitDialogEvent,
56785 _swigc__p_wxInputStream,
56786 _swigc__p_wxInternetFSHandler,
56787 _swigc__p_wxItemContainer,
56788 _swigc__p_wxJPEGHandler,
56789 _swigc__p_wxKeyEvent,
56790 _swigc__p_wxLayoutConstraints,
56791 _swigc__p_wxMaximizeEvent,
56792 _swigc__p_wxMemoryFSHandler,
56793 _swigc__p_wxMenu,
56794 _swigc__p_wxMenuBar,
56795 _swigc__p_wxMenuBarBase,
56796 _swigc__p_wxMenuEvent,
56797 _swigc__p_wxMenuItem,
56798 _swigc__p_wxMouseCaptureChangedEvent,
56799 _swigc__p_wxMouseCaptureLostEvent,
56800 _swigc__p_wxMouseEvent,
56801 _swigc__p_wxMoveEvent,
56802 _swigc__p_wxNavigationKeyEvent,
56803 _swigc__p_wxNcPaintEvent,
56804 _swigc__p_wxNotifyEvent,
56805 _swigc__p_wxObject,
56806 _swigc__p_wxOutputStream,
56807 _swigc__p_wxPCXHandler,
56808 _swigc__p_wxPNGHandler,
56809 _swigc__p_wxPNMHandler,
56810 _swigc__p_wxPaintEvent,
56811 _swigc__p_wxPaletteChangedEvent,
56812 _swigc__p_wxPaperSize,
56813 _swigc__p_wxPoint,
56814 _swigc__p_wxPoint2D,
56815 _swigc__p_wxPropagateOnce,
56816 _swigc__p_wxPropagationDisabler,
56817 _swigc__p_wxPyApp,
56818 _swigc__p_wxPyCommandEvent,
56819 _swigc__p_wxPyDropTarget,
56820 _swigc__p_wxPyEvent,
56821 _swigc__p_wxPyFileSystemHandler,
56822 _swigc__p_wxPyImageHandler,
56823 _swigc__p_wxPyInputStream,
56824 _swigc__p_wxPySizer,
56825 _swigc__p_wxPyValidator,
56826 _swigc__p_wxQuantize,
56827 _swigc__p_wxQueryNewPaletteEvent,
56828 _swigc__p_wxRealPoint,
56829 _swigc__p_wxRect,
56830 _swigc__p_wxRegion,
56831 _swigc__p_wxScrollEvent,
56832 _swigc__p_wxScrollWinEvent,
56833 _swigc__p_wxSetCursorEvent,
56834 _swigc__p_wxShowEvent,
56835 _swigc__p_wxSize,
56836 _swigc__p_wxSizeEvent,
56837 _swigc__p_wxSizer,
56838 _swigc__p_wxSizerItem,
56839 _swigc__p_wxStaticBox,
56840 _swigc__p_wxStaticBoxSizer,
56841 _swigc__p_wxStdDialogButtonSizer,
56842 _swigc__p_wxSysColourChangedEvent,
56843 _swigc__p_wxTIFFHandler,
56844 _swigc__p_wxToolTip,
56845 _swigc__p_wxUpdateUIEvent,
56846 _swigc__p_wxValidator,
56847 _swigc__p_wxVisualAttributes,
56848 _swigc__p_wxWindow,
56849 _swigc__p_wxWindowCreateEvent,
56850 _swigc__p_wxWindowDestroyEvent,
56851 _swigc__p_wxXPMHandler,
56852 _swigc__p_wxZipFSHandler,
56853 };
56854
56855
56856 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56857
56858 static swig_const_info swig_const_table[] = {
56859 {0, 0, 0, 0.0, 0, 0}};
56860
56861 #ifdef __cplusplus
56862 }
56863 #endif
56864 /* -----------------------------------------------------------------------------
56865 * Type initialization:
56866 * This problem is tough by the requirement that no dynamic
56867 * memory is used. Also, since swig_type_info structures store pointers to
56868 * swig_cast_info structures and swig_cast_info structures store pointers back
56869 * to swig_type_info structures, we need some lookup code at initialization.
56870 * The idea is that swig generates all the structures that are needed.
56871 * The runtime then collects these partially filled structures.
56872 * The SWIG_InitializeModule function takes these initial arrays out of
56873 * swig_module, and does all the lookup, filling in the swig_module.types
56874 * array with the correct data and linking the correct swig_cast_info
56875 * structures together.
56876 *
56877 * The generated swig_type_info structures are assigned staticly to an initial
56878 * array. We just loop though that array, and handle each type individually.
56879 * First we lookup if this type has been already loaded, and if so, use the
56880 * loaded structure instead of the generated one. Then we have to fill in the
56881 * cast linked list. The cast data is initially stored in something like a
56882 * two-dimensional array. Each row corresponds to a type (there are the same
56883 * number of rows as there are in the swig_type_initial array). Each entry in
56884 * a column is one of the swig_cast_info structures for that type.
56885 * The cast_initial array is actually an array of arrays, because each row has
56886 * a variable number of columns. So to actually build the cast linked list,
56887 * we find the array of casts associated with the type, and loop through it
56888 * adding the casts to the list. The one last trick we need to do is making
56889 * sure the type pointer in the swig_cast_info struct is correct.
56890 *
56891 * First off, we lookup the cast->type name to see if it is already loaded.
56892 * There are three cases to handle:
56893 * 1) If the cast->type has already been loaded AND the type we are adding
56894 * casting info to has not been loaded (it is in this module), THEN we
56895 * replace the cast->type pointer with the type pointer that has already
56896 * been loaded.
56897 * 2) If BOTH types (the one we are adding casting info to, and the
56898 * cast->type) are loaded, THEN the cast info has already been loaded by
56899 * the previous module so we just ignore it.
56900 * 3) Finally, if cast->type has not already been loaded, then we add that
56901 * swig_cast_info to the linked list (because the cast->type) pointer will
56902 * be correct.
56903 * ----------------------------------------------------------------------------- */
56904
56905 #ifdef __cplusplus
56906 extern "C" {
56907 #if 0
56908 } /* c-mode */
56909 #endif
56910 #endif
56911
56912 #if 0
56913 #define SWIGRUNTIME_DEBUG
56914 #endif
56915
56916 SWIGRUNTIME void
56917 SWIG_InitializeModule(void *clientdata) {
56918 size_t i;
56919 swig_module_info *module_head;
56920 static int init_run = 0;
56921
56922 clientdata = clientdata;
56923
56924 if (init_run) return;
56925 init_run = 1;
56926
56927 /* Initialize the swig_module */
56928 swig_module.type_initial = swig_type_initial;
56929 swig_module.cast_initial = swig_cast_initial;
56930
56931 /* Try and load any already created modules */
56932 module_head = SWIG_GetModule(clientdata);
56933 if (module_head) {
56934 swig_module.next = module_head->next;
56935 module_head->next = &swig_module;
56936 } else {
56937 /* This is the first module loaded */
56938 swig_module.next = &swig_module;
56939 SWIG_SetModule(clientdata, &swig_module);
56940 }
56941
56942 /* Now work on filling in swig_module.types */
56943 #ifdef SWIGRUNTIME_DEBUG
56944 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56945 #endif
56946 for (i = 0; i < swig_module.size; ++i) {
56947 swig_type_info *type = 0;
56948 swig_type_info *ret;
56949 swig_cast_info *cast;
56950
56951 #ifdef SWIGRUNTIME_DEBUG
56952 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56953 #endif
56954
56955 /* if there is another module already loaded */
56956 if (swig_module.next != &swig_module) {
56957 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56958 }
56959 if (type) {
56960 /* Overwrite clientdata field */
56961 #ifdef SWIGRUNTIME_DEBUG
56962 printf("SWIG_InitializeModule: found type %s\n", type->name);
56963 #endif
56964 if (swig_module.type_initial[i]->clientdata) {
56965 type->clientdata = swig_module.type_initial[i]->clientdata;
56966 #ifdef SWIGRUNTIME_DEBUG
56967 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56968 #endif
56969 }
56970 } else {
56971 type = swig_module.type_initial[i];
56972 }
56973
56974 /* Insert casting types */
56975 cast = swig_module.cast_initial[i];
56976 while (cast->type) {
56977 /* Don't need to add information already in the list */
56978 ret = 0;
56979 #ifdef SWIGRUNTIME_DEBUG
56980 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56981 #endif
56982 if (swig_module.next != &swig_module) {
56983 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56984 #ifdef SWIGRUNTIME_DEBUG
56985 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56986 #endif
56987 }
56988 if (ret) {
56989 if (type == swig_module.type_initial[i]) {
56990 #ifdef SWIGRUNTIME_DEBUG
56991 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56992 #endif
56993 cast->type = ret;
56994 ret = 0;
56995 } else {
56996 /* Check for casting already in the list */
56997 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56998 #ifdef SWIGRUNTIME_DEBUG
56999 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
57000 #endif
57001 if (!ocast) ret = 0;
57002 }
57003 }
57004
57005 if (!ret) {
57006 #ifdef SWIGRUNTIME_DEBUG
57007 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
57008 #endif
57009 if (type->cast) {
57010 type->cast->prev = cast;
57011 cast->next = type->cast;
57012 }
57013 type->cast = cast;
57014 }
57015 cast++;
57016 }
57017 /* Set entry in modules->types array equal to the type */
57018 swig_module.types[i] = type;
57019 }
57020 swig_module.types[i] = 0;
57021
57022 #ifdef SWIGRUNTIME_DEBUG
57023 printf("**** SWIG_InitializeModule: Cast List ******\n");
57024 for (i = 0; i < swig_module.size; ++i) {
57025 int j = 0;
57026 swig_cast_info *cast = swig_module.cast_initial[i];
57027 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
57028 while (cast->type) {
57029 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
57030 cast++;
57031 ++j;
57032 }
57033 printf("---- Total casts: %d\n",j);
57034 }
57035 printf("**** SWIG_InitializeModule: Cast List ******\n");
57036 #endif
57037 }
57038
57039 /* This function will propagate the clientdata field of type to
57040 * any new swig_type_info structures that have been added into the list
57041 * of equivalent types. It is like calling
57042 * SWIG_TypeClientData(type, clientdata) a second time.
57043 */
57044 SWIGRUNTIME void
57045 SWIG_PropagateClientData(void) {
57046 size_t i;
57047 swig_cast_info *equiv;
57048 static int init_run = 0;
57049
57050 if (init_run) return;
57051 init_run = 1;
57052
57053 for (i = 0; i < swig_module.size; i++) {
57054 if (swig_module.types[i]->clientdata) {
57055 equiv = swig_module.types[i]->cast;
57056 while (equiv) {
57057 if (!equiv->converter) {
57058 if (equiv->type && !equiv->type->clientdata)
57059 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
57060 }
57061 equiv = equiv->next;
57062 }
57063 }
57064 }
57065 }
57066
57067 #ifdef __cplusplus
57068 #if 0
57069 {
57070 /* c-mode */
57071 #endif
57072 }
57073 #endif
57074
57075
57076
57077 #ifdef __cplusplus
57078 extern "C" {
57079 #endif
57080
57081 /* Python-specific SWIG API */
57082 #define SWIG_newvarlink() SWIG_Python_newvarlink()
57083 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
57084 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
57085
57086 /* -----------------------------------------------------------------------------
57087 * global variable support code.
57088 * ----------------------------------------------------------------------------- */
57089
57090 typedef struct swig_globalvar {
57091 char *name; /* Name of global variable */
57092 PyObject *(*get_attr)(void); /* Return the current value */
57093 int (*set_attr)(PyObject *); /* Set the value */
57094 struct swig_globalvar *next;
57095 } swig_globalvar;
57096
57097 typedef struct swig_varlinkobject {
57098 PyObject_HEAD
57099 swig_globalvar *vars;
57100 } swig_varlinkobject;
57101
57102 SWIGINTERN PyObject *
57103 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
57104 return PyString_FromString("<Swig global variables>");
57105 }
57106
57107 SWIGINTERN PyObject *
57108 swig_varlink_str(swig_varlinkobject *v) {
57109 PyObject *str = PyString_FromString("(");
57110 swig_globalvar *var;
57111 for (var = v->vars; var; var=var->next) {
57112 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
57113 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
57114 }
57115 PyString_ConcatAndDel(&str,PyString_FromString(")"));
57116 return str;
57117 }
57118
57119 SWIGINTERN int
57120 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
57121 PyObject *str = swig_varlink_str(v);
57122 fprintf(fp,"Swig global variables ");
57123 fprintf(fp,"%s\n", PyString_AsString(str));
57124 Py_DECREF(str);
57125 return 0;
57126 }
57127
57128 SWIGINTERN void
57129 swig_varlink_dealloc(swig_varlinkobject *v) {
57130 swig_globalvar *var = v->vars;
57131 while (var) {
57132 swig_globalvar *n = var->next;
57133 free(var->name);
57134 free(var);
57135 var = n;
57136 }
57137 }
57138
57139 SWIGINTERN PyObject *
57140 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
57141 PyObject *res = NULL;
57142 swig_globalvar *var = v->vars;
57143 while (var) {
57144 if (strcmp(var->name,n) == 0) {
57145 res = (*var->get_attr)();
57146 break;
57147 }
57148 var = var->next;
57149 }
57150 if (res == NULL && !PyErr_Occurred()) {
57151 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57152 }
57153 return res;
57154 }
57155
57156 SWIGINTERN int
57157 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
57158 int res = 1;
57159 swig_globalvar *var = v->vars;
57160 while (var) {
57161 if (strcmp(var->name,n) == 0) {
57162 res = (*var->set_attr)(p);
57163 break;
57164 }
57165 var = var->next;
57166 }
57167 if (res == 1 && !PyErr_Occurred()) {
57168 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57169 }
57170 return res;
57171 }
57172
57173 SWIGINTERN PyTypeObject*
57174 swig_varlink_type(void) {
57175 static char varlink__doc__[] = "Swig var link object";
57176 static PyTypeObject varlink_type;
57177 static int type_init = 0;
57178 if (!type_init) {
57179 const PyTypeObject tmp
57180 = {
57181 PyObject_HEAD_INIT(NULL)
57182 0, /* Number of items in variable part (ob_size) */
57183 (char *)"swigvarlink", /* Type name (tp_name) */
57184 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
57185 0, /* Itemsize (tp_itemsize) */
57186 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
57187 (printfunc) swig_varlink_print, /* Print (tp_print) */
57188 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
57189 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
57190 0, /* tp_compare */
57191 (reprfunc) swig_varlink_repr, /* tp_repr */
57192 0, /* tp_as_number */
57193 0, /* tp_as_sequence */
57194 0, /* tp_as_mapping */
57195 0, /* tp_hash */
57196 0, /* tp_call */
57197 (reprfunc)swig_varlink_str, /* tp_str */
57198 0, /* tp_getattro */
57199 0, /* tp_setattro */
57200 0, /* tp_as_buffer */
57201 0, /* tp_flags */
57202 varlink__doc__, /* tp_doc */
57203 0, /* tp_traverse */
57204 0, /* tp_clear */
57205 0, /* tp_richcompare */
57206 0, /* tp_weaklistoffset */
57207 #if PY_VERSION_HEX >= 0x02020000
57208 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
57209 #endif
57210 #if PY_VERSION_HEX >= 0x02030000
57211 0, /* tp_del */
57212 #endif
57213 #ifdef COUNT_ALLOCS
57214 0,0,0,0 /* tp_alloc -> tp_next */
57215 #endif
57216 };
57217 varlink_type = tmp;
57218 varlink_type.ob_type = &PyType_Type;
57219 type_init = 1;
57220 }
57221 return &varlink_type;
57222 }
57223
57224 /* Create a variable linking object for use later */
57225 SWIGINTERN PyObject *
57226 SWIG_Python_newvarlink(void) {
57227 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
57228 if (result) {
57229 result->vars = 0;
57230 }
57231 return ((PyObject*) result);
57232 }
57233
57234 SWIGINTERN void
57235 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
57236 swig_varlinkobject *v = (swig_varlinkobject *) p;
57237 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
57238 if (gv) {
57239 size_t size = strlen(name)+1;
57240 gv->name = (char *)malloc(size);
57241 if (gv->name) {
57242 strncpy(gv->name,name,size);
57243 gv->get_attr = get_attr;
57244 gv->set_attr = set_attr;
57245 gv->next = v->vars;
57246 }
57247 }
57248 v->vars = gv;
57249 }
57250
57251 SWIGINTERN PyObject *
57252 SWIG_globals() {
57253 static PyObject *_SWIG_globals = 0;
57254 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
57255 return _SWIG_globals;
57256 }
57257
57258 /* -----------------------------------------------------------------------------
57259 * constants/methods manipulation
57260 * ----------------------------------------------------------------------------- */
57261
57262 /* Install Constants */
57263 SWIGINTERN void
57264 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
57265 PyObject *obj = 0;
57266 size_t i;
57267 for (i = 0; constants[i].type; ++i) {
57268 switch(constants[i].type) {
57269 case SWIG_PY_POINTER:
57270 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
57271 break;
57272 case SWIG_PY_BINARY:
57273 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
57274 break;
57275 default:
57276 obj = 0;
57277 break;
57278 }
57279 if (obj) {
57280 PyDict_SetItemString(d, constants[i].name, obj);
57281 Py_DECREF(obj);
57282 }
57283 }
57284 }
57285
57286 /* -----------------------------------------------------------------------------*/
57287 /* Fix SwigMethods to carry the callback ptrs when needed */
57288 /* -----------------------------------------------------------------------------*/
57289
57290 SWIGINTERN void
57291 SWIG_Python_FixMethods(PyMethodDef *methods,
57292 swig_const_info *const_table,
57293 swig_type_info **types,
57294 swig_type_info **types_initial) {
57295 size_t i;
57296 for (i = 0; methods[i].ml_name; ++i) {
57297 const char *c = methods[i].ml_doc;
57298 if (c && (c = strstr(c, "swig_ptr: "))) {
57299 int j;
57300 swig_const_info *ci = 0;
57301 const char *name = c + 10;
57302 for (j = 0; const_table[j].type; ++j) {
57303 if (strncmp(const_table[j].name, name,
57304 strlen(const_table[j].name)) == 0) {
57305 ci = &(const_table[j]);
57306 break;
57307 }
57308 }
57309 if (ci) {
57310 size_t shift = (ci->ptype) - types;
57311 swig_type_info *ty = types_initial[shift];
57312 size_t ldoc = (c - methods[i].ml_doc);
57313 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
57314 char *ndoc = (char*)malloc(ldoc + lptr + 10);
57315 if (ndoc) {
57316 char *buff = ndoc;
57317 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
57318 if (ptr) {
57319 strncpy(buff, methods[i].ml_doc, ldoc);
57320 buff += ldoc;
57321 strncpy(buff, "swig_ptr: ", 10);
57322 buff += 10;
57323 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
57324 methods[i].ml_doc = ndoc;
57325 }
57326 }
57327 }
57328 }
57329 }
57330 }
57331
57332 #ifdef __cplusplus
57333 }
57334 #endif
57335
57336 /* -----------------------------------------------------------------------------*
57337 * Partial Init method
57338 * -----------------------------------------------------------------------------*/
57339
57340 #ifdef __cplusplus
57341 extern "C"
57342 #endif
57343 SWIGEXPORT void SWIG_init(void) {
57344 PyObject *m, *d;
57345
57346 /* Fix SwigMethods to carry the callback ptrs when needed */
57347 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
57348
57349 m = Py_InitModule((char *) SWIG_name, SwigMethods);
57350 d = PyModule_GetDict(m);
57351
57352 SWIG_InitializeModule(0);
57353 SWIG_InstallConstants(d,swig_const_table);
57354
57355
57356
57357 #ifndef wxPyUSE_EXPORT
57358 // Make our API structure a CObject so other modules can import it
57359 // from this module.
57360 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
57361 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
57362 Py_XDECREF(cobj);
57363 #endif
57364
57365 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
57366 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
57367 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
57368 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
57369 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
57370 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
57371 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
57372 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
57373 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
57374 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
57375 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
57376 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
57377 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
57378 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
57379 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
57380 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
57381 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
57382 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
57383 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
57384 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
57385 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
57386 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
57387 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
57388 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
57389 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
57390 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
57391 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
57392 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
57393 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
57394 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
57395 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
57396 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
57397 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
57398 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
57399 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
57400 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
57401 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
57402 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
57403 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
57404 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
57405 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
57406 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
57407 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
57408 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
57409 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
57410 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
57411 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
57412 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
57413 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
57414 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
57415 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
57416 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
57417 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
57418 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
57419 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
57420 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
57421 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
57422 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
57423 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
57424 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
57425 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
57426 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
57427 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
57428 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
57429 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
57430 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
57431 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
57432 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
57433 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
57434 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
57435 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
57436 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
57437 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
57438 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
57439 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
57440 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
57441 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
57442 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
57443 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
57444 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
57445 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
57446 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
57447 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
57448 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
57449 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
57450 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
57451 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
57452 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
57453 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
57454 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
57455 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
57456 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
57457 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
57458 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
57459 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
57460 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
57461 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
57462 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
57463 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
57464 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
57465 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
57466 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
57467 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
57468 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
57469 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
57470 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
57471 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
57472 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
57473 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
57474 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
57475 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
57476 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
57477 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
57478 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
57479 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
57480 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
57481 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
57482 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
57483 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
57484 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
57485 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
57486 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
57487 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
57488 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
57489 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
57490 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
57491 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
57492 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
57493 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
57494 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
57495 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
57496 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
57497 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
57498 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
57499 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
57500 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
57501 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
57502 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
57503 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
57504 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
57505 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
57506 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
57507 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
57508 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
57509 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
57510 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
57511 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
57512 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
57513 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
57514 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
57515 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
57516 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
57517 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
57518 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
57519 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
57520 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
57521 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
57522 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
57523 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
57524 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
57525 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
57526 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
57527 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
57528 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
57529 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
57530 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
57531 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
57532 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
57533 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
57534 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
57535 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
57536 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
57537 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
57538 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
57539 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
57540 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
57541 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
57542 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57543 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57544 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57545 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57546 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57547 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57548 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57549 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57550 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57551 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57552 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57553 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57554 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57555 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57556 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57557 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57558 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57559 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57560 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57561 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57562 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57563 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57564 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57565 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57566 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57567 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57568 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57569 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57570 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57571 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57572 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57573 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57574 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57575 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57576 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57577 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57578 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57579 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57580 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57581 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57582 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57583 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57584 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57585 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57586 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57587 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57588 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57589 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57590 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57591 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57592 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57593 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57594 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57595 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57596 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57597 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57598 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57599 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57600 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57601 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57602 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57603 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57604 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57605 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57606 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57607 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57608 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57609 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57610 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57611 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57612 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57613 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57614 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57615 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57616 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57617 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57618 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57619 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57620 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57621 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57622 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57623 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57624 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57625 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57626 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57627 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57628 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57629 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57630 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57631 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57632 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57633 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57634 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57635 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57636 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57637 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57638 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57639 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57640 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57641 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57642 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57643 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57644 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57645 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57646 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57647 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57648 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57649 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57650 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57651 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57652 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57653 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57654 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57655 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57656 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57657 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57658 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57659 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57660 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57661 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57662 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57663 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57664 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57665 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57666 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57667 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57668 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57669 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57670 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57671 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57672 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57673 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57674 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57675 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57676 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57677 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57678 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57679 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57680 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57681 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57682 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57683 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57684 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57685 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57686 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57687 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57688 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57689 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57690 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57691 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57692 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57693 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57694 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57695 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57696 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57697 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57698 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57699 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57700 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57701 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57702 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57703 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57704 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57705 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57706 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57707 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57708 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57709 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57710 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57711 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57712 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57713 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57714 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57715 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57716 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57717 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57718 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57719 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57720 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57721 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57722 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57723 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57724 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57725 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57726 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57727 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57728 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57729 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57730 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57731 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57732 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57733 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57734 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57735 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57736 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57737 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57738 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57739 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57740 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57741 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57742 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57743 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57744 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57745 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57746 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57747 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57748 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57749 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57750 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57751 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57752 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57753 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57754 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57755 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57756 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57757 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57758 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57759 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57760 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57761 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57762 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57763 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57764 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57765 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57766 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57767 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57768 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57769 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57770 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57771 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57772 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57773 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57774 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57775 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57776 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57777 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57778 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57779 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57780 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57781 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57782 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57783 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57784 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57785 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57786 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57787 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57788 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57789 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57790 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57791 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57792 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57793 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57794 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57795 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57796 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57797 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57798 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57799 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57800 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57801 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57802 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57803 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57804 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57805 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57806 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57807 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57808 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57809 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57810 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57811 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57812 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57813 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57814 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57815 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57816 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57817 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57818 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57819 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57820 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57821 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57822 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57823 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57824 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57825 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57826 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57827 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57828 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57829 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57830 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57831 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57832 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57833 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57834 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57835 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57836 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57837 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57838 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57839 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57840 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57841 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57842 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57843 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57844 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57845 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57846 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57847 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57848 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57849 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57850 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57851 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57852 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57853 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57854 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57855 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57856 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57857 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57858 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57859 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57860 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57861 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57862 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57863 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57864 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57865 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57866 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57867 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57868 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57869 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57870 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57871 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57872 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57873 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57874 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57875 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57876 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57877 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57878 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57879 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57880 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57881 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57882 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57883 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57884 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57885 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57886 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57887 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57888 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57889 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57890 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57891 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57892 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57893 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57894 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57895 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57896 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57897 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57898 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57899 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57900 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57901 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57902 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57903 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57904 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57905 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57906 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57907 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57908 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57909 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57910 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57911 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57912 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57913 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57914 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57915 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57916 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57917 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57918 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57919 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57920 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57921 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57922 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57923 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57924 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57925 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57926 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57927 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57928 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57929 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57930 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57931 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57932 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57933 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57934 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57935 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57936 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57937 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57938 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57939 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57940 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57941 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57942 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57943 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57944 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57945 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57946 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57947 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57948 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57949 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57950 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57951 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57952 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57953 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57954 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57955 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57956 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57957 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57958 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57959 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57960 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57961 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57962 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57963 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57964 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57965 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57966 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57967 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57968 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57969 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57970 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57971 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57972 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57973 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57974 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57975 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57976 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57977 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57978 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57979 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57980 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57981 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57982 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57983 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57984 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57985 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57986 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57987 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57988 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57989 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57990 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57991 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57992 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57993 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57994 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57995 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57996 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57997 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57998 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57999 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
58000 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
58001 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
58002 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
58003 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
58004 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
58005 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
58006 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
58007 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
58008 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
58009 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
58010 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
58011 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
58012 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
58013 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
58014 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
58015 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
58016 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
58017 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
58018 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
58019 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
58020 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
58021 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
58022 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
58023 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
58024
58025 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
58026
58027
58028 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
58029
58030 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
58031 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
58032 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
58033 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
58034 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
58035 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
58036 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
58037 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
58038 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
58039 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
58040 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
58041 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
58042 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
58043 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
58044 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
58045 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
58046 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
58047 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
58048 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
58049 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
58050 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
58051 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
58052 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
58053 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
58054 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
58055 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
58056 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
58057 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
58058 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
58059 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
58060 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
58061 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
58062 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
58063 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
58064 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
58065 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
58066 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
58067 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
58068 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
58069 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
58070 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
58071 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
58072 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
58073 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
58074 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
58075 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
58076 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
58077 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
58078 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
58079 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
58080 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
58081 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
58082 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
58083 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
58084 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
58085 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
58086 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
58087 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
58088 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
58089 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
58090 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
58091 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
58092 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
58093 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
58094 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
58095 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
58096 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
58097 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
58098 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
58099 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
58100 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
58101 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
58102 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
58103 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
58104 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
58105 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
58106 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
58107 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
58108 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
58109 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
58110 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
58111 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
58112 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
58113 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
58114 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
58115 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
58116 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
58117 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
58118 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
58119 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
58120 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
58121 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
58122 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
58123 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
58124 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
58125 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
58126 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
58127 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
58128 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
58129 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
58130 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
58131 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
58132 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
58133 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
58134 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
58135 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
58136 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
58137 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
58138 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
58139 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
58140 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
58141 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
58142 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
58143 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
58144 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
58145 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
58146 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
58147 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
58148 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
58149 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
58150 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
58151 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
58152 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
58153 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
58154 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
58155 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
58156 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
58157 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
58158 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
58159 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
58160 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
58161 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
58162 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
58163 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
58164 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
58165 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
58166 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
58167 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
58168 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
58169 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
58170 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
58171 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
58172 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
58173 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
58174 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
58175 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
58176 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
58177 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
58178 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
58179 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
58180 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
58181 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
58182 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
58183 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
58184 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
58185 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
58186 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
58187 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
58188 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
58189 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
58190 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
58191 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
58192 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
58193 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
58194 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
58195 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
58196 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
58197 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
58198 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
58199 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
58200 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
58201 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
58202 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
58203 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
58204 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
58205 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
58206 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
58207 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
58208 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
58209 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
58210 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
58211 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
58212 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
58213 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
58214 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
58215 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
58216 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
58217 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
58218 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
58219 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
58220 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
58221 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
58222 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
58223 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
58224 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
58225 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
58226 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
58227 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
58228 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
58229 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
58230 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
58231 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
58232 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
58233 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
58234 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
58235 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
58236 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
58237 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
58238 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
58239 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
58240 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
58241 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
58242 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
58243 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
58244
58245 // Initialize threading, some globals and such
58246 __wxPyPreStart(d);
58247
58248
58249 // Although these are defined in __version__ they need to be here too so
58250 // that an assert can be done to ensure that the wxPython and the wxWindows
58251 // versions match.
58252 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
58253 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
58254 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
58255
58256 }
58257
wxWidgets (Impactor)